opensportslib 0.3.0__tar.gz → 0.3.0.dev1__tar.gz

{opensportslib-0.3.0/opensportslib.egg-info → opensportslib-0.3.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.0
+Version: 0.3.0.dev1
 Summary: OpenSportsLib is the professional library, designed for advanced video understanding in sports. It provides state-of-the-art tools for action recognition, spotting, retrieval, and captioning, making it ideal for researchers, analysts, and developers working with sports video data.
 Author: Jeet Vora
 Requires-Python: >=3.12
@@ -26,6 +26,7 @@ Requires-Dist: tabulate
 Requires-Dist: pytorch-lightning
 Requires-Dist: pandas
 Requires-Dist: pyarrow
+Requires-Dist: h5py==3.16.0
 Requires-Dist: huggingface_hub
 Requires-Dist: easydict
 Provides-Extra: test
@@ -316,10 +317,25 @@ single_prediction = my_model.infer(
 ```
 
 Use `opensportslib/configs/vqa/xvars.yaml` with `opensportslib setup --vqa_xvars`
-for the X-VARS-compatible backend, or `opensportslib/configs/vqa/qwen.yaml` with
-`opensportslib setup --vqa_qwen` for the Qwen-compatible backend. The Qwen
-backend currently supports `Qwen/Qwen2.5-7B-Instruct` and
-`Qwen/Qwen3.5-9B-Base`.
+for the X-VARS backend. OpenSportsLib supports three VQA options:
+
+- `opensportslib/configs/vqa/xvars.yaml`
+  Original X-VARS / Video-ChatGPT path.
+- CLIP features + Qwen
+  Use `opensportslib/configs/vqa/qwen.yaml` for inference and
+  `opensportslib/configs/vqa/qwen_lora.yaml` for LoRA training.
+- `opensportslib/configs/vqa/qwen3_vl_native.yaml`
+  Full end-to-end native QwenVL path. This is the single canonical QwenVL
+  config; change `MODEL.components.llm_decoder.params.repo_id` to switch model
+  IDs.
+
+Use `opensportslib setup --vqa_qwen` for both the CLIP+Qwen and native QwenVL
+paths. The CLIP+Qwen configs support `Qwen/Qwen2.5-7B-Instruct` and
+`Qwen/Qwen3.5-9B-Base`. The native QwenVL config defaults to
+`Qwen/Qwen3-VL-8B-Instruct` and supports:
+
+- `Qwen/Qwen3-VL-8B-Instruct`
+- `Qwen/Qwen2.5-VL-7B-Instruct`
 
 For X-VARS, `feature_source: indexed_or_raw_clip` prefers indexed CLIP features
 when available and falls back to extracting CLIP features from raw video during

{opensportslib-0.3.0 → opensportslib-0.3.0.dev1}/README.md

@@ -281,10 +281,25 @@ single_prediction = my_model.infer(
 ```
 
 Use `opensportslib/configs/vqa/xvars.yaml` with `opensportslib setup --vqa_xvars`
-for the X-VARS-compatible backend, or `opensportslib/configs/vqa/qwen.yaml` with
-`opensportslib setup --vqa_qwen` for the Qwen-compatible backend. The Qwen
-backend currently supports `Qwen/Qwen2.5-7B-Instruct` and
-`Qwen/Qwen3.5-9B-Base`.
+for the X-VARS backend. OpenSportsLib supports three VQA options:
+
+- `opensportslib/configs/vqa/xvars.yaml`
+  Original X-VARS / Video-ChatGPT path.
+- CLIP features + Qwen
+  Use `opensportslib/configs/vqa/qwen.yaml` for inference and
+  `opensportslib/configs/vqa/qwen_lora.yaml` for LoRA training.
+- `opensportslib/configs/vqa/qwen3_vl_native.yaml`
+  Full end-to-end native QwenVL path. This is the single canonical QwenVL
+  config; change `MODEL.components.llm_decoder.params.repo_id` to switch model
+  IDs.
+
+Use `opensportslib setup --vqa_qwen` for both the CLIP+Qwen and native QwenVL
+paths. The CLIP+Qwen configs support `Qwen/Qwen2.5-7B-Instruct` and
+`Qwen/Qwen3.5-9B-Base`. The native QwenVL config defaults to
+`Qwen/Qwen3-VL-8B-Instruct` and supports:
+
+- `Qwen/Qwen3-VL-8B-Instruct`
+- `Qwen/Qwen2.5-VL-7B-Instruct`
 
 For X-VARS, `feature_source: indexed_or_raw_clip` prefers indexed CLIP features
 when available and falls back to extracting CLIP features from raw video during

{opensportslib-0.3.0 → opensportslib-0.3.0.dev1}/opensportslib/apis/classification.py

@@ -17,6 +17,17 @@ from opensportslib.core.config.accessors import (
 )
 from opensportslib.core.utils.config import expand
 
+
+def _is_tracking_graph_modality(modality):
+    return str(modality).lower() in {
+        "tracking",
+        "tracking_parquet",
+        "tracking_h5",
+        "player_centroids_h5",
+        "player_joints_h5",
+    }
+
+
 class ClassificationModel(BaseTaskModel):
     """Top-level task wrapper for classification."""
 
@@ -100,7 +111,7 @@ class ClassificationModel(BaseTaskModel):
         trainer.model = model
 
         modality = get_data_modality(config)
-        use_tracking_collate = modality in {"tracking", "tracking_parquet"}
+        use_tracking_collate = _is_tracking_graph_modality(modality)
         logging.info(
             "Worker setup | mode=%s | modality=%s | tracking_collate=%s",
             mode,

{opensportslib-0.3.0 → opensportslib-0.3.0.dev1}/opensportslib/apis/localization.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import time
+from types import SimpleNamespace
 
 from opensportslib.apis.base_task_model import BaseTaskModel
 from opensportslib.core.config.accessors import (
@@ -14,6 +15,8 @@ from opensportslib.core.config.accessors import (
     get_split_annotation_path,
     get_split_cfg,
     set_split_annotation_path,
+    set_loader_backend,
+    get_model_family,
 )
 from opensportslib.core.utils.config import expand
 
@@ -21,6 +24,17 @@ from opensportslib.core.utils.config import expand
 class LocalizationModel(BaseTaskModel):
     """Top-level task wrapper for localization / spotting."""
 
+    _HF_BACKEND_SPLIT_TYPES = {
+        "dali": {
+            "VideoGameWithOpencv": "VideoGameWithDali",
+            "VideoGameWithOpencvVideo": "VideoGameWithDaliVideo",
+        },
+        "opencv": {
+            "VideoGameWithDali": "VideoGameWithOpencv",
+            "VideoGameWithDaliVideo": "VideoGameWithOpencvVideo",
+        },
+    }
+
     # def __init__(self, config=None, weights=None):
     #     super().__init__(config=config, weights=None)
     #     if weights is not None:
@@ -61,6 +75,82 @@ class LocalizationModel(BaseTaskModel):
                 device,
             )
 
+    @staticmethod
+    def _device_type(device) -> str:
+        device_type = getattr(device, "type", device)
+        return str(device_type).split(":", 1)[0].lower()
+
+    @staticmethod
+    def _is_hf_repo_weights(weights: str | None) -> bool:
+        if not weights:
+            return False
+        from opensportslib.core.utils.config import is_local_path
+
+        return not is_local_path(weights)
+
+    @staticmethod
+    def _iter_split_items(splits):
+        if splits is None:
+            return []
+        if isinstance(splits, dict):
+            return list(splits.items())
+        return list(vars(splits).items())
+
+    @staticmethod
+    def _ensure_namespace(parent, attr: str):
+        current = getattr(parent, attr, None)
+        if current is None:
+            current = SimpleNamespace()
+            setattr(parent, attr, current)
+        return current
+
+    def _normalize_opencv_dataloader(self, split_name: str, split_cfg) -> None:
+        dataloader = getattr(split_cfg, "dataloader", None)
+        if dataloader is None:
+            dataloader = SimpleNamespace()
+            setattr(split_cfg, "dataloader", dataloader)
+
+        if getattr(dataloader, "batch_size", None) is None:
+            dataloader.batch_size = 1
+        if getattr(dataloader, "shuffle", None) is None:
+            dataloader.shuffle = split_name == "train"
+        if getattr(dataloader, "num_workers", None) is None:
+            dataloader.num_workers = 0
+        if getattr(dataloader, "pin_memory", None) is None:
+            dataloader.pin_memory = False
+
+    def _adapt_hf_backend_for_device(self, weights: str | None) -> None:
+        if not self._is_hf_repo_weights(weights):
+            return
+
+        from opensportslib.core.utils.config import select_device
+
+        device = select_device(self.config.SYSTEM)
+        backend = "dali" if self._device_type(device) == "cuda" else "opencv"
+        current_backend = get_loader_backend(self.config)
+        set_loader_backend(self.config, backend)
+
+        common = getattr(getattr(self.config, "DATA", None), "common", None)
+        if common is None:
+            return
+        splits = self._ensure_namespace(common, "splits")
+        remap = self._HF_BACKEND_SPLIT_TYPES[backend]
+
+        for split_name, split_cfg in self._iter_split_items(splits):
+            split_type = getattr(split_cfg, "type", None)
+            if split_type in remap:
+                setattr(split_cfg, "type", remap[split_type])
+            if backend == "opencv":
+                self._normalize_opencv_dataloader(split_name, split_cfg)
+
+        if current_backend != backend:
+            logging.info(
+                "HF localization runtime backend override: %s -> %s for weights=%s",
+                current_backend,
+                backend,
+                weights,
+            )
+
     def load_weights(
         self,
         weights: str | None = None,
@@ -79,6 +169,7 @@ class LocalizationModel(BaseTaskModel):
         if weights is None:
             raise ValueError("`weights` must be provided to load_weights().")
 
+        self._adapt_hf_backend_for_device(weights)
         device = select_device(self.config.SYSTEM)
         self._gate_multi_gpu_by_device(device)
         if self.model is None:
@@ -170,6 +261,11 @@ class LocalizationModel(BaseTaskModel):
 
         del kwargs
 
+        if str(get_model_family(self.config)).lower() == "rulebased":
+            raise NotImplementedError(
+                "RuleBased localization models are inference-only; call infer() instead of train()."
+            )
+
         train_set = self._resolve_split_path("train", train_set)
         valid_set = self._resolve_split_path("valid", valid_set)
         self._set_split_path("train", train_set)
@@ -177,8 +273,10 @@ class LocalizationModel(BaseTaskModel):
         # E2E validation mAP uses the `valid_data_frames` split; keep it in sync
         # with explicit valid annotation overrides.
         self._set_split_path("valid_data_frames", valid_set)
-        
+
         self.config = resolve_config_omega(self.config, weights=weights)
+        effective_weights = weights if weights is not None else self.last_loaded_weights
+        self._adapt_hf_backend_for_device(effective_weights)
         check_config(self.config, split="train")
         init_wandb(
             self.config_path,
@@ -190,8 +288,6 @@ class LocalizationModel(BaseTaskModel):
         logging.info("Configuration:")
         logging.info(self.config)
 
-        effective_weights = weights if weights is not None else self.last_loaded_weights
-
         def set_seed(seed):
             random.seed(seed)
             np.random.seed(seed)
@@ -292,6 +388,8 @@ class LocalizationModel(BaseTaskModel):
         self._set_split_path("test", test_set)
 
         self.config = resolve_config_omega(self.config, weights=weights)
+        effective_weights = weights if weights is not None else self.last_loaded_weights
+        self._adapt_hf_backend_for_device(effective_weights)
         check_config(self.config, split="test")
         self.config.infer_split = whether_infer_split(get_split_cfg(self.config, "test"))
 
@@ -307,8 +405,6 @@ class LocalizationModel(BaseTaskModel):
 
         start = time.time()
 
-        effective_weights = weights if weights is not None else self.last_loaded_weights
-
         if effective_weights is not None:
             if self.model is None or self.last_loaded_weights != effective_weights:
                 self.load_weights(weights=effective_weights)
@@ -362,6 +458,8 @@ class LocalizationModel(BaseTaskModel):
         test_set = self._resolve_split_path("test", test_set)
         self._set_split_path("test", test_set)
         self.config = resolve_config_omega(self.config, weights=weights)
+        effective_weights = weights if weights is not None else self.last_loaded_weights
+        self._adapt_hf_backend_for_device(effective_weights)
         check_config(self.config, split="test")
         self.config.infer_split = whether_infer_split(get_split_cfg(self.config, "test"))
 

{opensportslib-0.3.0 → opensportslib-0.3.0.dev1}/opensportslib/apis/vqa.py

@@ -51,6 +51,7 @@ class VQAModel(BaseTaskModel):
         return_queue=None,
         train_set=None,
         valid_set=None,
+        resume_from_checkpoint=None,
         use_wandb=False,
     ):
         import torch
@@ -97,14 +98,10 @@ class VQAModel(BaseTaskModel):
             train_data = build_dataset(config, train_set, None, split="train")
             valid_data = build_dataset(config, valid_set, None, split="valid")
             trainer = Trainer_VQA(config)
-            ckpt = trainer.train(
-                None,
-                train_data,
-                valid_data,
-                rank=rank,
-                world_size=world_size,
-                use_wandb=use_wandb,
-            )
+            train_kwargs = {"rank": rank, "world_size": world_size, "use_wandb": use_wandb}
+            if resume_from_checkpoint is not None:
+                train_kwargs["resume_from_checkpoint"] = resume_from_checkpoint
+            ckpt = trainer.train(None, train_data, valid_data, **train_kwargs)
             if rank == 0 and return_queue is not None:
                 return_queue.put(ckpt)
         finally:
@@ -139,37 +136,73 @@ class VQAModel(BaseTaskModel):
         train_set: str | None = None,
         valid_set: str | None = None,
         weights: str | None = None,
+        resume_from_checkpoint: str | None = None,
+        use_ddp: bool | None = None,
         use_wandb: bool = True,
         **kwargs,
     ) -> str | None:
         del kwargs
+
+        self.config = resolve_config_omega(self.config, weights=weights)
+        execution = get_train_execution(self.config)
+        backend = str(execution.get("training_backend", "placeholder")).lower()
+        vqa_backend = get_vqa_backend(self.config)
+        if vqa_backend == "qwen_xvars_infer" and backend != "qwen_xvars_lora":
+            raise ValueError(
+                "The 'qwen_xvars_infer' backend requires TRAIN.execution.training_backend='qwen_xvars_lora' for train()."
+            )
+        if vqa_backend == "qwen_vl_native_infer" and backend != "qwen_vl_native_lora":
+            raise ValueError(
+                "The 'qwen_vl_native_infer' backend requires TRAIN.execution.training_backend='qwen_vl_native_lora' for train()."
+            )
         import torch
         import torch.multiprocessing as mp
 
-        self.config = resolve_config_omega(self.config, weights=weights)
-        if get_vqa_backend(self.config) == "qwen_xvars_infer":
-            raise ValueError("The 'qwen_xvars_infer' backend is inference-only and does not support train().")
         train_set = self._resolve_split_path("train", train_set)
         valid_set = self._resolve_split_path("valid", valid_set)
-        execution = get_train_execution(self.config)
-        backend = str(execution.get("training_backend", "placeholder")).lower()
-        if backend == "xvars_videochatgpt_lora":
-            world_size = torch.cuda.device_count() or get_system_gpu_count(self.config)
+        if backend in {"xvars_videochatgpt_lora", "qwen_xvars_lora", "qwen_vl_native_lora"}:
             requested_gpus = get_system_gpu_count(self.config)
-            use_ddp = world_size > 1 and int(requested_gpus) > 1
+            available_gpus = int(torch.cuda.device_count() or 0)
+            if requested_gpus > 0:
+                world_size = min(available_gpus, int(requested_gpus)) if available_gpus > 0 else int(requested_gpus)
+            else:
+                world_size = available_gpus
+            effective_world_size = max(int(world_size), 1)
+            if use_ddp is None:
+                launch_ddp = effective_world_size > 1
+            else:
+                launch_ddp = bool(use_ddp) and effective_world_size > 1
+            if requested_gpus > 0 and available_gpus > 0 and requested_gpus != available_gpus:
+                logging.info(
+                    "VQA train GPU selection | requested=%s | available=%s | launching=%s",
+                    requested_gpus,
+                    available_gpus,
+                    effective_world_size if launch_ddp else 1,
+                )
             logging.info(
-                "VQA train launch | mode=%s | world_size=%s",
-                "ddp" if use_ddp else "single",
-                world_size if use_ddp else 1,
+                "VQA train launch | mode=%s | requested_gpus=%s | available_gpus=%s | world_size=%s",
+                "ddp" if launch_ddp else "single",
+                requested_gpus,
+                available_gpus,
+                effective_world_size if launch_ddp else 1,
             )
 
             ctx = mp.get_context("spawn")
             queue = ctx.SimpleQueue()
-            if use_ddp:
+            if launch_ddp:
                 mp.spawn(
                     VQAModel._worker_ddp,
-                    args=(world_size, self.config_path, self.config, queue, train_set, valid_set, use_wandb),
-                    nprocs=world_size,
+                    args=(
+                        effective_world_size,
+                        self.config_path,
+                        self.config,
+                        queue,
+                        train_set,
+                        valid_set,
+                        resume_from_checkpoint,
+                        use_wandb,
+                    ),
+                    nprocs=effective_world_size,
                 )
             else:
                 VQAModel._worker_ddp(
@@ -180,6 +213,7 @@ class VQAModel(BaseTaskModel):
                     return_queue=queue,
                     train_set=train_set,
                     valid_set=valid_set,
+                    resume_from_checkpoint=resume_from_checkpoint,
                     use_wandb=use_wandb,
                 )
             ckpt = queue.get()
@@ -189,7 +223,7 @@ class VQAModel(BaseTaskModel):
 
         raise ValueError(
             f"Unsupported VQA training backend '{backend}'. "
-            "Only 'xvars_videochatgpt_lora' is supported."
+            "Only 'xvars_videochatgpt_lora' and 'qwen_xvars_lora' are supported."
         )
 
     def infer(
@@ -216,8 +250,6 @@ class VQAModel(BaseTaskModel):
         self.config = resolve_config_omega(self.config, weights=weights)
         backend = get_vqa_backend(self.config)
         effective_weights = weights if weights is not None else self.last_loaded_weights
-        if backend == "qwen_xvars_infer" and effective_weights is not None:
-            raise ValueError("The 'qwen_xvars_infer' backend does not support adapter weights for infer().")
         _set_model_checkpoint_path(self.config, effective_weights)
         self.trainer = Trainer_VQA(self.config)
         if effective_weights is not None:
@@ -237,6 +269,8 @@ class VQAModel(BaseTaskModel):
                     "question": str(question).strip(),
                     "references": [],
                     "video_path": resolved_video_path,
+                    "frame_paths": [],
+                    "video_frames": [],
                     "video_spatio_temporal_features": None,
                     "prior_prediction_text": "",
                     "labels": {},

{opensportslib-0.3.0 → opensportslib-0.3.0.dev1}/opensportslib/configs/default.yaml

@@ -2,7 +2,7 @@ SYSTEM:
   paths:
     log_dir: ./logs
     save_dir: ./checkpoints
-  device: cuda
+  device: auto
   gpu:
     id: 0
   reproducibility:

opensportslib-0.3.0.dev1/opensportslib/configs/localization/h5_header_distance.yaml

@@ -0,0 +1,93 @@
+TASK: localization
+VERSION: 2
+
+SYSTEM:
+  paths:
+    work_dir: ./outputs/header_spotting_distance
+  device: cpu
+  gpu:
+    count: 0
+
+DATA:
+  common:
+    dataset_name: h5_headers
+    data_root: ./data
+    classes:
+      - header
+    splits:
+      test:
+        type: H5OSLJsonSpotting
+        annotation_path: ./data/h5.json
+        source_path: ./data
+        dataloader:
+          batch_size: 1
+          shuffle: false
+          num_workers: 0
+          pin_memory: false
+  inputs:
+    tracking:
+      modality: player_joints_h5
+      representation: raw
+      source:
+        format: h5
+      sampling: {}
+      transform: {}
+      augmentations: {}
+      params: {}
+
+MODEL:
+  metadata:
+    family: RuleBased
+    runner:
+      type: runner_h5_header_rule
+  components:
+    rule:
+      kind: algorithm
+      source:
+        provider: opensportslib
+        registry: rule_based
+        name: h5_header_distance
+      params:
+        label: header
+        head_name: action
+        distance_threshold_m: 0.5
+        min_confidence: 0.5
+        confidence_mode: linear_inverse_distance
+        confidence_power: 1.0
+        nms_window_ms: 1000
+        nms_scope: sample
+        ball_tolerance_ms: 60
+        chunk_size: 100000
+        head_joints: [nose, neck, l_eye, r_eye, l_ear, r_ear]
+        required_input_type: player_joints_h5
+        ball_path_field: ball_path
+        timestamp_field: timestamp_utc
+        output_task: action_spotting
+        include_diagnostics: true
+        position_ms_origin: joint_h5_start
+        metadata_start_field: start_utc
+        metadata_end_field: end_utc
+        ball_coordinate_fields: [x, y, z]
+        joint_coordinate_suffixes: [x, y, z]
+        identity_fields: [player_id, jersey_number, team_id, is_home]
+        invalid_coordinate_values: [-200.0]
+        sideline_filter_enabled: true
+        pitch_half_width_m: 50.0
+        sideline_exclusion_m: 1.0
+        sideline_reference: ball_y
+        trajectory_filter_enabled: false
+        trajectory_change_mode: either_angle_or_speed
+        trajectory_pre_window_ms: 200
+        trajectory_post_window_ms: 200
+        trajectory_min_angle_deg: 25.0
+        trajectory_min_speed_delta_ratio: 0.25
+        trajectory_min_vector_norm_m: 0.05
+        trajectory_use_xy_only: false
+        confidence_output_key: confidence_score
+  topology: []
+
+TRAIN:
+  trainer:
+    type: trainer_rule_based
+  execution:
+    enabled: false

opensportslib-0.3.0.dev1/opensportslib/configs/localization/h5_header_distance_angle.yaml

@@ -0,0 +1,93 @@
+TASK: localization
+VERSION: 2
+
+SYSTEM:
+  paths:
+    work_dir: ./outputs/header_spotting_distance_angle
+  device: cpu
+  gpu:
+    count: 0
+
+DATA:
+  common:
+    dataset_name: h5_headers
+    data_root: ./data
+    classes:
+      - header
+    splits:
+      test:
+        type: H5OSLJsonSpotting
+        annotation_path: ./data/h5.json
+        source_path: ./data
+        dataloader:
+          batch_size: 1
+          shuffle: false
+          num_workers: 0
+          pin_memory: false
+  inputs:
+    tracking:
+      modality: player_joints_h5
+      representation: raw
+      source:
+        format: h5
+      sampling: {}
+      transform: {}
+      augmentations: {}
+      params: {}
+
+MODEL:
+  metadata:
+    family: RuleBased
+    runner:
+      type: runner_h5_header_rule
+  components:
+    rule:
+      kind: algorithm
+      source:
+        provider: opensportslib
+        registry: rule_based
+        name: h5_header_distance_angle
+      params:
+        label: header
+        head_name: action
+        distance_threshold_m: 0.5
+        min_confidence: 0.5
+        confidence_mode: linear_inverse_distance
+        confidence_power: 1.0
+        nms_window_ms: 1000
+        nms_scope: sample
+        ball_tolerance_ms: 60
+        chunk_size: 100000
+        head_joints: [nose, neck, l_eye, r_eye, l_ear, r_ear]
+        required_input_type: player_joints_h5
+        ball_path_field: ball_path
+        timestamp_field: timestamp_utc
+        output_task: action_spotting
+        include_diagnostics: true
+        position_ms_origin: joint_h5_start
+        metadata_start_field: start_utc
+        metadata_end_field: end_utc
+        ball_coordinate_fields: [x, y, z]
+        joint_coordinate_suffixes: [x, y, z]
+        identity_fields: [player_id, jersey_number, team_id, is_home]
+        invalid_coordinate_values: [-200.0]
+        sideline_filter_enabled: true
+        pitch_half_width_m: 50.0
+        sideline_exclusion_m: 1.0
+        sideline_reference: ball_y
+        trajectory_filter_enabled: true
+        trajectory_change_mode: angle
+        trajectory_pre_window_ms: 200
+        trajectory_post_window_ms: 200
+        trajectory_min_angle_deg: 25.0
+        trajectory_min_speed_delta_ratio: 0.25
+        trajectory_min_vector_norm_m: 0.05
+        trajectory_use_xy_only: false
+        confidence_output_key: confidence_score
+  topology: []
+
+TRAIN:
+  trainer:
+    type: trainer_rule_based
+  execution:
+    enabled: false