]> Piment Noir Git Repositories - freqai-strategies.git/commitdiff
refactor: document QuickAdapter option indexes
authorJérôme Benoit <jerome.benoit@piment-noir.org>
Sat, 19 Sep 2026 22:50:23 +0000 (00:50 +0200)
committerGitHub <noreply@github.com>
Sat, 19 Sep 2026 22:50:23 +0000 (00:50 +0200)
* refactor: document QuickAdapter option indexes

* style: harmonize QuickAdapter index comments

* fix: remove index annotation from label docstring

* fix: remove duplicate QuickAdapter index comments

* fix: remove repeated smoothing annotation

* fix: remove duplicate wrap annotation

* refactor: deduplicate QuickAdapter label annotations

* fix: complete QuickAdapter index annotations

quickadapter/.basedpyright/diagnostics.json
quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py
quickadapter/user_data/strategies/LabelTransformer.py
quickadapter/user_data/strategies/QuickAdapterV3.py
quickadapter/user_data/strategies/Utils.py

index 8536c67223e6a6ff04f35ccd885e0a371910349e..59617457b61ed49ad2b08906de4be247416a2f34 100644 (file)
   "diagnostics": [
     {
       "endCharacter": 46,
-      "endLine": 1353,
+      "endLine": 1368,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"str | None\" cannot be assigned to parameter \"default\" of type \"str\" in function \"_validate_label_selection_metric\"\n  Type \"str | None\" is not assignable to type \"str\"\n    \"None\" is not assignable to \"str\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 24,
-      "startLine": 1353
+      "startLine": 1368
     },
     {
       "endCharacter": 79,
-      "endLine": 2135,
+      "endLine": 2150,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"index\" for class \"NDArray[Unknown]\"\n  Attribute \"index\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 74,
-      "startLine": 2135
+      "startLine": 2150
     },
     {
       "endCharacter": 72,
-      "endLine": 2137,
+      "endLine": 2152,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"index\" for class \"NDArray[Unknown]\"\n  Attribute \"index\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 67,
-      "startLine": 2137
+      "startLine": 2152
     },
     {
       "endCharacter": 90,
-      "endLine": 2146,
+      "endLine": 2161,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"index\" for class \"NDArray[Unknown]\"\n  Attribute \"index\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 85,
-      "startLine": 2146
+      "startLine": 2161
     },
     {
       "endCharacter": 34,
-      "endLine": 2159,
+      "endLine": 2174,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"train_features\" of type \"DataFrame\" in function \"_filter_train_by_mask\"\n  Type \"Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"DataFrame\"\n    \"list[Unknown]\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 2159
+      "startLine": 2174
     },
     {
       "endCharacter": 32,
-      "endLine": 2160,
+      "endLine": 2175,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"train_labels\" of type \"DataFrame\" in function \"_filter_train_by_mask\"\n  Type \"Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"DataFrame\"\n    \"list[Unknown]\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 2160
+      "startLine": 2175
     },
     {
       "endCharacter": 38,
-      "endLine": 2161,
+      "endLine": 2176,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"train_weights\" of type \"NDArray[floating[Any]]\" in function \"_filter_train_by_mask\"\n  Type \"Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"NDArray[floating[Any]]\"\n    \"list[Unknown]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 2161
+      "startLine": 2176
     },
     {
       "endCharacter": 59,
-      "endLine": 2164,
+      "endLine": 2179,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Unknown | NDArray[Unknown] | Any | list[Unknown] | None\" cannot be assigned to parameter \"train_label_weights\" of type \"NDArray[floating[Any]] | None\" in function \"_filter_train_by_mask\"\n  Type \"Unknown | NDArray[Unknown] | Any | list[Unknown] | None\" is not assignable to type \"NDArray[floating[Any]] | None\"\n    Type \"list[Unknown]\" is not assignable to type \"NDArray[floating[Any]] | None\"\n      \"list[Unknown]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"\n      \"list[Unknown]\" is not assignable to \"None\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 40,
-      "startLine": 2164
+      "startLine": 2179
     },
     {
       "endCharacter": 34,
-      "endLine": 2198,
+      "endLine": 2213,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"features\" of type \"DataFrame\" in function \"_shuffle_split_rows\"\n  Type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"DataFrame\"\n    \"list[Unknown]\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 2198
+      "startLine": 2213
     },
     {
       "endCharacter": 32,
-      "endLine": 2199,
+      "endLine": 2214,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"labels\" of type \"DataFrame\" in function \"_shuffle_split_rows\"\n  Type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"DataFrame\"\n    \"list[Unknown]\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 2199
+      "startLine": 2214
     },
     {
       "endCharacter": 38,
-      "endLine": 2200,
+      "endLine": 2215,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"base_weights\" of type \"NDArray[floating[Any]]\" in function \"_shuffle_split_rows\"\n  Type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"NDArray[floating[Any]]\"\n    \"list[Unknown]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 2200
+      "startLine": 2215
     },
     {
       "endCharacter": 39,
-      "endLine": 2201,
+      "endLine": 2216,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown] | None\" cannot be assigned to parameter \"label_weights\" of type \"NDArray[floating[Any]] | None\" in function \"_shuffle_split_rows\"\n  Type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown] | None\" is not assignable to type \"NDArray[floating[Any]] | None\"\n    Type \"list[Unknown]\" is not assignable to type \"NDArray[floating[Any]] | None\"\n      \"list[Unknown]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"\n      \"list[Unknown]\" is not assignable to \"None\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 2201
+      "startLine": 2216
     },
     {
       "endCharacter": 37,
-      "endLine": 2208,
+      "endLine": 2223,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Unknown | NDArray[Unknown] | Any | list[Unknown] | DataFrame\" cannot be assigned to parameter \"features\" of type \"DataFrame\" in function \"_shuffle_split_rows\"\n  Type \"Unknown | NDArray[Unknown] | Any | list[Unknown] | DataFrame\" is not assignable to type \"DataFrame\"\n    \"list[Unknown]\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 24,
-      "startLine": 2208
+      "startLine": 2223
     },
     {
       "endCharacter": 35,
-      "endLine": 2209,
+      "endLine": 2224,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Unknown | NDArray[Unknown] | Any | list[Unknown] | DataFrame\" cannot be assigned to parameter \"labels\" of type \"DataFrame\" in function \"_shuffle_split_rows\"\n  Type \"Unknown | NDArray[Unknown] | Any | list[Unknown] | DataFrame\" is not assignable to type \"DataFrame\"\n    \"list[Unknown]\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 24,
-      "startLine": 2209
+      "startLine": 2224
     },
     {
       "endCharacter": 41,
-      "endLine": 2210,
+      "endLine": 2225,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Unknown | NDArray[Unknown] | Any | list[Unknown] | ndarray[_AnyShape, dtype[floating[Any]]]\" cannot be assigned to parameter \"base_weights\" of type \"NDArray[floating[Any]]\" in function \"_shuffle_split_rows\"\n  Type \"Unknown | NDArray[Unknown] | Any | list[Unknown] | ndarray[_AnyShape, dtype[floating[Any]]]\" is not assignable to type \"NDArray[floating[Any]]\"\n    \"list[Unknown]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 24,
-      "startLine": 2210
+      "startLine": 2225
     },
     {
       "endCharacter": 42,
-      "endLine": 2211,
+      "endLine": 2226,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Unknown | NDArray[Unknown] | Any | list[Unknown] | ndarray[_AnyShape, dtype[floating[Any]]] | None\" cannot be assigned to parameter \"label_weights\" of type \"NDArray[floating[Any]] | None\" in function \"_shuffle_split_rows\"\n  Type \"Unknown | NDArray[Unknown] | Any | list[Unknown] | ndarray[_AnyShape, dtype[floating[Any]]] | None\" is not assignable to type \"NDArray[floating[Any]] | None\"\n    Type \"list[Unknown]\" is not assignable to type \"NDArray[floating[Any]] | None\"\n      \"list[Unknown]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"\n      \"list[Unknown]\" is not assignable to \"None\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 24,
-      "startLine": 2211
+      "startLine": 2226
     },
     {
       "endCharacter": 30,
-      "endLine": 2229,
+      "endLine": 2244,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"base_weights\" of type \"NDArray[floating[Any]]\" in function \"_compose_train_weights_with_support\"\n  Type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"NDArray[floating[Any]]\"\n    \"list[Unknown]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 2229
+      "startLine": 2244
     },
     {
       "endCharacter": 31,
-      "endLine": 2230,
+      "endLine": 2245,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown] | None\" cannot be assigned to parameter \"label_weights\" of type \"NDArray[floating[Any]] | None\" in function \"_compose_train_weights_with_support\"\n  Type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown] | None\" is not assignable to type \"NDArray[floating[Any]] | None\"\n    Type \"list[Unknown]\" is not assignable to type \"NDArray[floating[Any]] | None\"\n      \"list[Unknown]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"\n      \"list[Unknown]\" is not assignable to \"None\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 2230
+      "startLine": 2245
     },
     {
       "endCharacter": 33,
-      "endLine": 2236,
+      "endLine": 2251,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"base_weights\" of type \"NDArray[floating[Any]]\" in function \"_compose_eval_weights\"\n  Type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"NDArray[floating[Any]]\"\n    \"list[Unknown]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2236
+      "startLine": 2251
     },
     {
       "endCharacter": 34,
-      "endLine": 2237,
+      "endLine": 2252,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown] | None\" cannot be assigned to parameter \"label_weights\" of type \"NDArray[floating[Any]] | None\" in function \"_compose_eval_weights\"\n  Type \"NDArray[floating[Any]] | Unknown | NDArray[Unknown] | Any | list[Unknown] | None\" is not assignable to type \"NDArray[floating[Any]] | None\"\n    Type \"list[Unknown]\" is not assignable to type \"NDArray[floating[Any]] | None\"\n      \"list[Unknown]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"\n      \"list[Unknown]\" is not assignable to \"None\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2237
+      "startLine": 2252
     },
     {
       "endCharacter": 26,
-      "endLine": 2244,
+      "endLine": 2259,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"train_df\" of type \"DataFrame\" in function \"build_data_dictionary\"\n  Type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"DataFrame\"\n    \"list[Unknown]\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 2244
+      "startLine": 2259
     },
     {
       "endCharacter": 25,
-      "endLine": 2245,
+      "endLine": 2260,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"test_df\" of type \"DataFrame\" in function \"build_data_dictionary\"\n  Type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"DataFrame\"\n    \"list[Unknown]\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 2245
+      "startLine": 2260
     },
     {
       "endCharacter": 24,
-      "endLine": 2246,
+      "endLine": 2261,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"train_labels\" of type \"DataFrame\" in function \"build_data_dictionary\"\n  Type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"DataFrame\"\n    \"list[Unknown]\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 2246
+      "startLine": 2261
     },
     {
       "endCharacter": 23,
-      "endLine": 2247,
+      "endLine": 2262,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" cannot be assigned to parameter \"test_labels\" of type \"DataFrame\" in function \"build_data_dictionary\"\n  Type \"DataFrame | Unknown | NDArray[Unknown] | Any | list[Unknown]\" is not assignable to type \"DataFrame\"\n    \"list[Unknown]\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 2247
+      "startLine": 2262
     },
     {
       "endCharacter": 87,
-      "endLine": 2551,
+      "endLine": 2569,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"index\" for class \"NDArray[Unknown]\"\n  Attribute \"index\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 82,
-      "startLine": 2551
+      "startLine": 2569
     },
     {
       "endCharacter": 68,
-      "endLine": 2552,
+      "endLine": 2570,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"index\" for class \"NDArray[Unknown]\"\n  Attribute \"index\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 63,
-      "startLine": 2552
+      "startLine": 2570
     },
     {
       "endCharacter": 63,
-      "endLine": 2563,
+      "endLine": 2581,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"index\" for class \"NDArray[Unknown]\"\n  Attribute \"index\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 58,
-      "startLine": 2563
+      "startLine": 2581
     },
     {
       "endCharacter": 47,
-      "endLine": 2565,
+      "endLine": 2583,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"loc\" for class \"NDArray[Unknown]\"\n  Attribute \"loc\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 44,
-      "startLine": 2565
+      "startLine": 2583
     },
     {
       "endCharacter": 47,
-      "endLine": 2565,
+      "endLine": 2583,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"loc\" for class \"list[Unknown]\"\n  Attribute \"loc\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 44,
-      "startLine": 2565
+      "startLine": 2583
     },
     {
       "endCharacter": 43,
-      "endLine": 2566,
+      "endLine": 2584,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"loc\" for class \"NDArray[Unknown]\"\n  Attribute \"loc\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 40,
-      "startLine": 2566
+      "startLine": 2584
     },
     {
       "endCharacter": 43,
-      "endLine": 2566,
+      "endLine": 2584,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"loc\" for class \"list[Unknown]\"\n  Attribute \"loc\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 40,
-      "startLine": 2566
+      "startLine": 2584
     },
     {
       "endCharacter": 31,
-      "endLine": 2587,
+      "endLine": 2605,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"NDArray[Unknown]\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 26,
-      "startLine": 2587
+      "startLine": 2605
     },
     {
       "endCharacter": 31,
-      "endLine": 2587,
+      "endLine": 2605,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"list[Unknown]\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 26,
-      "startLine": 2587
+      "startLine": 2605
     },
     {
       "endCharacter": 60,
-      "endLine": 2587,
+      "endLine": 2605,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"NDArray[Unknown]\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 55,
-      "startLine": 2587
+      "startLine": 2605
     },
     {
       "endCharacter": 60,
-      "endLine": 2587,
+      "endLine": 2605,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"list[Unknown]\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 55,
-      "startLine": 2587
+      "startLine": 2605
     },
     {
       "endCharacter": 73,
-      "endLine": 2599,
+      "endLine": 2617,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Unknown | Any | ((value: Unknown, start: SupportsIndex = 0, stop: SupportsIndex = sys.maxsize, /) -> int)\" cannot be assigned to parameter \"target\" of type \"Index[Any]\" in function \"get_indexer\"\n  Type \"Unknown | Any | ((value: Unknown, start: SupportsIndex = 0, stop: SupportsIndex = sys.maxsize, /) -> int)\" is not assignable to type \"Index[Any]\"\n    \"MethodType\" is not assignable to \"Index[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 53,
-      "startLine": 2599
+      "startLine": 2617
     },
     {
       "endCharacter": 73,
-      "endLine": 2599,
+      "endLine": 2617,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"index\" for class \"NDArray[Unknown]\"\n  Attribute \"index\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 68,
-      "startLine": 2599
+      "startLine": 2617
     },
     {
       "endCharacter": 83,
-      "endLine": 2600,
+      "endLine": 2618,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Unknown | Any | ((value: Unknown, start: SupportsIndex = 0, stop: SupportsIndex = sys.maxsize, /) -> int)\" cannot be assigned to parameter \"target\" of type \"Index[Any]\" in function \"get_indexer\"\n  Type \"Unknown | Any | ((value: Unknown, start: SupportsIndex = 0, stop: SupportsIndex = sys.maxsize, /) -> int)\" is not assignable to type \"Index[Any]\"\n    \"MethodType\" is not assignable to \"Index[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 58,
-      "startLine": 2600
+      "startLine": 2618
     },
     {
       "endCharacter": 83,
-      "endLine": 2600,
+      "endLine": 2618,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"index\" for class \"NDArray[Unknown]\"\n  Attribute \"index\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 78,
-      "startLine": 2600
+      "startLine": 2618
     },
     {
       "endCharacter": 46,
-      "endLine": 2835,
+      "endLine": 2853,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"Buffer\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 41,
-      "startLine": 2835
+      "startLine": 2853
     },
     {
       "endCharacter": 46,
-      "endLine": 2835,
+      "endLine": 2853,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"_NestedSequence[_SupportsArray[dtype[Any]]]\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 41,
-      "startLine": 2835
+      "startLine": 2853
     },
     {
       "endCharacter": 46,
-      "endLine": 2835,
+      "endLine": 2853,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"_NestedSequence[complex | bytes | str]\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 41,
-      "startLine": 2835
+      "startLine": 2853
     },
     {
       "endCharacter": 46,
-      "endLine": 2835,
+      "endLine": 2853,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"_SupportsArray[dtype[Any]]\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 41,
-      "startLine": 2835
+      "startLine": 2853
     },
     {
       "endCharacter": 46,
-      "endLine": 2835,
+      "endLine": 2853,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"bytes\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 41,
-      "startLine": 2835
+      "startLine": 2853
     },
     {
       "endCharacter": 46,
-      "endLine": 2835,
+      "endLine": 2853,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"complex\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 41,
-      "startLine": 2835
+      "startLine": 2853
     },
     {
       "endCharacter": 46,
-      "endLine": 2835,
+      "endLine": 2853,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Cannot access attribute \"empty\" for class \"str\"\n  Attribute \"empty\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 41,
-      "startLine": 2835
+      "startLine": 2853
     },
     {
       "endCharacter": 41,
-      "endLine": 2842,
+      "endLine": 2860,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"ArrayLike\" cannot be assigned to parameter \"features\" of type \"DataFrame\" in function \"_sanitize_pipeline_weights\"\n  Type \"ArrayLike\" is not assignable to type \"DataFrame\"\n    \"Buffer\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2842
+      "startLine": 2860
     },
     {
       "endCharacter": 39,
-      "endLine": 2891,
+      "endLine": 2909,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"ArrayLike\" cannot be assigned to parameter \"features\" of type \"DataFrame\" in function \"_sanitize_pipeline_weights\"\n  Type \"ArrayLike\" is not assignable to type \"DataFrame\"\n    \"Buffer\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 2891
+      "startLine": 2909
     },
     {
       "endCharacter": 19,
-      "endLine": 3001,
+      "endLine": 3019,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"int | Any | None\" cannot be assigned to parameter \"gap\" of type \"int\" in function \"__init__\"\n  Type \"int | Any | None\" is not assignable to type \"int\"\n    \"None\" is not assignable to \"int\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 3001
+      "startLine": 3019
     },
     {
       "endCharacter": 21,
-      "endLine": 3113,
+      "endLine": 3131,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"X\" of type \"DataFrame\" in function \"hp_objective\"\n  Type \"Any | None\" is not assignable to type \"DataFrame\"\n    \"None\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 3113
+      "startLine": 3131
     },
     {
       "endCharacter": 21,
-      "endLine": 3114,
+      "endLine": 3132,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"y\" of type \"DataFrame\" in function \"hp_objective\"\n  Type \"Any | None\" is not assignable to type \"DataFrame\"\n    \"None\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 3114
+      "startLine": 3132
     },
     {
       "endCharacter": 33,
-      "endLine": 3115,
+      "endLine": 3133,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"train_weights\" of type \"NDArray[floating[Any]]\" in function \"hp_objective\"\n  Type \"Any | None\" is not assignable to type \"NDArray[floating[Any]]\"\n    \"None\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 3115
+      "startLine": 3133
     },
     {
       "endCharacter": 32,
-      "endLine": 3116,
+      "endLine": 3134,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"X_validation\" of type \"DataFrame\" in function \"hp_objective\"\n  Type \"Any | None\" is not assignable to type \"DataFrame\"\n    \"None\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 3116
+      "startLine": 3134
     },
     {
       "endCharacter": 32,
-      "endLine": 3117,
+      "endLine": 3135,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"y_validation\" of type \"DataFrame\" in function \"hp_objective\"\n  Type \"Any | None\" is not assignable to type \"DataFrame\"\n    \"None\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 3117
+      "startLine": 3135
     },
     {
       "endCharacter": 38,
-      "endLine": 3118,
+      "endLine": 3136,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"validation_weights\" of type \"NDArray[floating[Any]]\" in function \"hp_objective\"\n  Type \"Any | None\" is not assignable to type \"NDArray[floating[Any]]\"\n    \"None\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 3118
+      "startLine": 3136
     },
     {
       "endCharacter": 24,
-      "endLine": 3139,
+      "endLine": 3157,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"X_test\" of type \"DataFrame\" in function \"make_test_set_and_weights\"\n  Type \"Any | None\" is not assignable to type \"DataFrame\"\n    \"None\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 3139
+      "startLine": 3157
     },
     {
       "endCharacter": 24,
-      "endLine": 3140,
+      "endLine": 3158,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"y_test\" of type \"DataFrame\" in function \"make_test_set_and_weights\"\n  Type \"Any | None\" is not assignable to type \"DataFrame\"\n    \"None\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 3140
+      "startLine": 3158
     },
     {
       "endCharacter": 30,
-      "endLine": 3141,
+      "endLine": 3159,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"test_weights\" of type \"NDArray[floating[Any]]\" in function \"make_test_set_and_weights\"\n  Type \"Any | None\" is not assignable to type \"NDArray[floating[Any]]\"\n    \"None\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 3141
+      "startLine": 3159
     },
     {
       "endCharacter": 15,
-      "endLine": 3147,
+      "endLine": 3165,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"X\" of type \"DataFrame\" in function \"fit_regressor\"\n  Type \"Any | None\" is not assignable to type \"DataFrame\"\n    \"None\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 14,
-      "startLine": 3147
+      "startLine": 3165
     },
     {
       "endCharacter": 15,
-      "endLine": 3148,
+      "endLine": 3166,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"y\" of type \"DataFrame\" in function \"fit_regressor\"\n  Type \"Any | None\" is not assignable to type \"DataFrame\"\n    \"None\" is not assignable to \"DataFrame\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 14,
-      "startLine": 3148
+      "startLine": 3166
     },
     {
       "endCharacter": 39,
-      "endLine": 3149,
+      "endLine": 3167,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"train_weights\" of type \"NDArray[floating[Any]]\" in function \"fit_regressor\"\n  Type \"Any | None\" is not assignable to type \"NDArray[floating[Any]]\"\n    \"None\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 26,
-      "startLine": 3149
+      "startLine": 3167
     },
     {
       "endCharacter": 38,
-      "endLine": 3159,
+      "endLine": 3177,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "\"columns\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 31,
-      "startLine": 3159
+      "startLine": 3177
     },
     {
       "endCharacter": 34,
-      "endLine": 3160,
+      "endLine": 3178,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "\"index\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 29,
-      "startLine": 3160
+      "startLine": 3178
     },
     {
       "endCharacter": 82,
-      "endLine": 3162,
+      "endLine": 3180,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "\"copy\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 78,
-      "startLine": 3162
+      "startLine": 3180
     },
     {
       "endCharacter": 62,
-      "endLine": 3461,
+      "endLine": 3479,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "\"get_pair_dataframe\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 44,
-      "startLine": 3461
+      "startLine": 3479
     },
     {
       "endCharacter": 68,
-      "endLine": 3841,
+      "endLine": 3859,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Type \"floating[Any] | NDArray[float64]\" is not assignable to return type \"NDArray[floating[Any]]\"\n  Type \"floating[Any] | NDArray[float64]\" is not assignable to type \"NDArray[floating[Any]]\"\n    \"floating[Any]\" is not assignable to \"ndarray[_AnyShape, dtype[floating[Any]]]\"",
       "rule": "reportReturnType",
       "severity": "error",
       "startCharacter": 15,
-      "startLine": 3837
+      "startLine": 3855
     },
     {
       "endCharacter": 13,
-      "endLine": 3870,
+      "endLine": 3888,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "No overloads for \"cdist\" match the provided arguments",
       "rule": "reportCallIssue",
       "severity": "error",
       "startCharacter": 19,
-      "startLine": 3865
+      "startLine": 3883
     },
     {
       "endCharacter": 38,
-      "endLine": 3868,
+      "endLine": 3886,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"str\" cannot be assigned to parameter \"metric\" of type \"_MetricFunc\" in function \"cdist\"\n  Type \"str\" is not assignable to type \"_MetricFunc\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 23,
-      "startLine": 3868
+      "startLine": 3886
     },
     {
       "endCharacter": 9,
-      "endLine": 3973,
+      "endLine": 3991,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "No overloads for \"pdist\" match the provided arguments",
       "rule": "reportCallIssue",
       "severity": "error",
       "startCharacter": 36,
-      "startLine": 3971
+      "startLine": 3989
     },
     {
       "endCharacter": 42,
-      "endLine": 3972,
+      "endLine": 3990,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"str\" cannot be assigned to parameter \"metric\" of type \"_MetricFunc\" in function \"pdist\"\n  Type \"str\" is not assignable to type \"_MetricFunc\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 27,
-      "startLine": 3972
+      "startLine": 3990
     },
     {
       "endCharacter": 9,
-      "endLine": 4050,
+      "endLine": 4068,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "No overloads for \"cdist\" match the provided arguments",
       "rule": "reportCallIssue",
       "severity": "error",
       "startCharacter": 15,
-      "startLine": 4045
+      "startLine": 4063
     },
     {
       "endCharacter": 34,
-      "endLine": 4048,
+      "endLine": 4066,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"str\" cannot be assigned to parameter \"metric\" of type \"_MetricFunc\" in function \"cdist\"\n  Type \"str\" is not assignable to type \"_MetricFunc\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 19,
-      "startLine": 4048
+      "startLine": 4066
     },
     {
       "endCharacter": 99,
-      "endLine": 4239,
+      "endLine": 4257,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "No overloads for \"pdist\" match the provided arguments",
       "rule": "reportCallIssue",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 4239
+      "startLine": 4257
     },
     {
       "endCharacter": 79,
-      "endLine": 4239,
+      "endLine": 4257,
       "file": "quickadapter/user_data/freqaimodels/QuickAdapterRegressorV3.py",
       "message": "Argument of type \"str\" cannot be assigned to parameter \"metric\" of type \"_MetricFunc\" in function \"pdist\"\n  Type \"str\" is not assignable to type \"_MetricFunc\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 64,
-      "startLine": 4239
+      "startLine": 4257
     },
     {
       "endCharacter": 55,
-      "endLine": 222,
+      "endLine": 223,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Type \"int\" is not assignable to declared type \"cached_property[int]\"\n  \"int\" is not assignable to \"cached_property[int]\"",
       "rule": "reportAssignmentType",
       "severity": "error",
       "startCharacter": 24,
-      "startLine": 222
+      "startLine": 223
     },
     {
       "endCharacter": 15,
-      "endLine": 258,
+      "endLine": 259,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Class variable \"minimal_roi\" overrides instance variable of same name in class \"IStrategy\"",
       "rule": "reportIncompatibleVariableOverride",
       "severity": "error",
       "startCharacter": 4,
-      "startLine": 258
+      "startLine": 259
     },
     {
       "endCharacter": 72,
-      "endLine": 258,
+      "endLine": 259,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"*\" not supported for types \"cached_property[int]\" and \"Literal[864]\"",
       "rule": "reportOperatorIssue",
       "severity": "error",
       "startCharacter": 49,
-      "startLine": 258
+      "startLine": 259
     },
     {
       "endCharacter": 64,
-      "endLine": 271,
+      "endLine": 272,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"timeframe\" of type \"str\" in function \"timeframe_to_minutes\"\n  Type \"Any | None\" is not assignable to type \"str\"\n    \"None\" is not assignable to \"str\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 36,
-      "startLine": 271
+      "startLine": 272
     },
     {
       "endCharacter": 17,
-      "endLine": 280,
+      "endLine": 281,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "\"can_short\" overrides symbol of same name in class \"IStrategy\"\n  \"property\" is not assignable to \"bool\"",
       "rule": "reportIncompatibleVariableOverride",
       "severity": "error",
       "startCharacter": 8,
-      "startLine": 280
+      "startLine": 281
     },
     {
       "endCharacter": 19,
-      "endLine": 284,
+      "endLine": 285,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "\"plot_config\" overrides symbol of same name in class \"IStrategy\"\n  \"cached_property[dict[str, Any]]\" is not assignable to \"dict[Unknown, Unknown]\"",
       "rule": "reportIncompatibleVariableOverride",
       "severity": "error",
       "startCharacter": 8,
-      "startLine": 284
+      "startLine": 285
     },
     {
       "endCharacter": 19,
-      "endLine": 328,
+      "endLine": 329,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "\"protections\" overrides symbol of same name in class \"IStrategy\"\n  \"cached_property[list[dict[str, Any]]]\" is not assignable to \"list[Unknown]\"",
       "rule": "reportIncompatibleVariableOverride",
       "severity": "error",
       "startCharacter": 8,
-      "startLine": 328
+      "startLine": 329
     },
     {
       "endCharacter": 28,
-      "endLine": 401,
+      "endLine": 402,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "\"startup_candle_count\" overrides symbol of same name in class \"IStrategy\"\n  \"property\" is not assignable to \"int\"",
       "rule": "reportIncompatibleVariableOverride",
       "severity": "error",
       "startCharacter": 8,
-      "startLine": 401
+      "startLine": 402
     },
     {
       "endCharacter": 44,
-      "endLine": 460,
+      "endLine": 461,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"/\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 460
+      "startLine": 461
     },
     {
       "endCharacter": 38,
-      "endLine": 715,
+      "endLine": 716,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "\"to_numpy\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 30,
-      "startLine": 715
+      "startLine": 716
     },
     {
       "endCharacter": 44,
-      "endLine": 748,
+      "endLine": 749,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"-\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 38,
-      "startLine": 748
+      "startLine": 749
     },
     {
       "endCharacter": 38,
-      "endLine": 756,
+      "endLine": 757,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Object of type \"None\" is not subscriptable",
       "rule": "reportOptionalSubscript",
       "severity": "error",
       "startCharacter": 36,
-      "startLine": 756
+      "startLine": 757
     },
     {
       "endCharacter": 39,
-      "endLine": 757,
+      "endLine": 758,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Object of type \"None\" is not subscriptable",
       "rule": "reportOptionalSubscript",
       "severity": "error",
       "startCharacter": 37,
-      "startLine": 757
+      "startLine": 758
     },
     {
       "endCharacter": 38,
-      "endLine": 758,
+      "endLine": 759,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Object of type \"None\" is not subscriptable",
       "rule": "reportOptionalSubscript",
       "severity": "error",
       "startCharacter": 36,
-      "startLine": 758
+      "startLine": 759
     },
     {
       "endCharacter": 44,
-      "endLine": 781,
+      "endLine": 782,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"-\" not supported for types \"Series[Any] | None\" and \"Series[Any] | None\"\n  Operator \"-\" not supported for types \"Series[Any]\" and \"None\"\n  Operator \"-\" not supported for types \"None\" and \"Series[Any]\"\n  Operator \"-\" not supported for types \"None\" and \"None\"",
       "rule": "reportOperatorIssue",
       "severity": "error",
       "startCharacter": 29,
-      "startLine": 781
+      "startLine": 782
     },
     {
       "endCharacter": 66,
-      "endLine": 781,
+      "endLine": 782,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"s1\" of type \"Series[Any]\" in function \"non_zero_diff\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 61,
-      "startLine": 781
+      "startLine": 782
     },
     {
       "endCharacter": 72,
-      "endLine": 781,
+      "endLine": 782,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"s2\" of type \"Series[Any]\" in function \"non_zero_diff\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 68,
-      "startLine": 781
+      "startLine": 782
     },
     {
       "endCharacter": 56,
-      "endLine": 785,
+      "endLine": 788,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 50,
-      "startLine": 785
+      "startLine": 788
     },
     {
       "endCharacter": 58,
-      "endLine": 786,
+      "endLine": 789,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 52,
-      "startLine": 786
+      "startLine": 789
     },
     {
       "endCharacter": 57,
-      "endLine": 787,
+      "endLine": 790,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 51,
-      "startLine": 787
+      "startLine": 790
     },
     {
       "endCharacter": 44,
-      "endLine": 790,
+      "endLine": 793,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"series\" of type \"Series[Any]\" in function \"zlema\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 38,
-      "startLine": 790
+      "startLine": 793
     },
     {
       "endCharacter": 44,
-      "endLine": 791,
+      "endLine": 794,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"series\" of type \"Series[Any]\" in function \"zlema\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 38,
-      "startLine": 791
+      "startLine": 794
     },
     {
       "endCharacter": 44,
-      "endLine": 792,
+      "endLine": 795,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"series\" of type \"Series[Any]\" in function \"zlema\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 38,
-      "startLine": 792
+      "startLine": 795
     },
     {
       "endCharacter": 61,
-      "endLine": 793,
+      "endLine": 796,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 55,
-      "startLine": 793
+      "startLine": 796
     },
     {
       "endCharacter": 61,
-      "endLine": 794,
+      "endLine": 797,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 55,
-      "startLine": 794
+      "startLine": 797
     },
     {
       "endCharacter": 61,
-      "endLine": 795,
+      "endLine": 798,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 55,
-      "startLine": 795
+      "startLine": 798
     },
     {
       "endCharacter": 81,
-      "endLine": 803,
+      "endLine": 806,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any]\" cannot be assigned to parameter \"p2\" of type \"T@get_distance\" in function \"get_distance\"\n  \"Series[Any]\" is not assignable to \"float\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 58,
-      "startLine": 803
+      "startLine": 806
     },
     {
       "endCharacter": 67,
-      "endLine": 816,
+      "endLine": 819,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 61,
-      "startLine": 816
+      "startLine": 819
     },
     {
       "endCharacter": 68,
-      "endLine": 817,
+      "endLine": 820,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 62,
-      "startLine": 817
+      "startLine": 820
     },
     {
       "endCharacter": 67,
-      "endLine": 818,
+      "endLine": 821,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 61,
-      "startLine": 818
+      "startLine": 821
     },
     {
       "endCharacter": 44,
-      "endLine": 819,
+      "endLine": 822,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"-\" not supported for types \"Series[Any] | None\" and \"Series[Any] | None\"\n  Operator \"-\" not supported for types \"Series[Any]\" and \"None\" when expected type is \"_SetItemValueNotDataFrame\"\n  Operator \"-\" not supported for types \"None\" and \"Series[Any]\" when expected type is \"_SetItemValueNotDataFrame\"\n  Operator \"-\" not supported for types \"None\" and \"None\" when expected type is \"_SetItemValueNotDataFrame\"",
       "rule": "reportOperatorIssue",
       "severity": "error",
       "startCharacter": 30,
-      "startLine": 819
+      "startLine": 822
     },
     {
       "endCharacter": 56,
-      "endLine": 820,
+      "endLine": 823,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "No overloads for \"__call__\" match the provided arguments",
       "rule": "reportCallIssue",
       "severity": "error",
       "startCharacter": 31,
-      "startLine": 820
+      "startLine": 823
     },
     {
       "endCharacter": 47,
-      "endLine": 820,
+      "endLine": 823,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"x1\" of type \"ArrayLike\" in function \"__call__\"\n  Type \"Series[Any] | None\" is not assignable to type \"ArrayLike\"\n    Type \"None\" is not assignable to type \"ArrayLike\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"_SupportsArray[dtype[Any]]\"\n        \"__array__\" is not present\n      \"None\" is incompatible with protocol \"_NestedSequence[_SupportsArray[dtype[Any]]]\"\n        \"__len__\" is not present\n  ...",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 42,
-      "startLine": 820
+      "startLine": 823
     },
     {
       "endCharacter": 55,
-      "endLine": 820,
+      "endLine": 823,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"x2\" of type \"ArrayLike\" in function \"__call__\"\n  Type \"Series[Any] | None\" is not assignable to type \"ArrayLike\"\n    Type \"None\" is not assignable to type \"ArrayLike\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"_SupportsArray[dtype[Any]]\"\n        \"__array__\" is not present\n      \"None\" is incompatible with protocol \"_NestedSequence[_SupportsArray[dtype[Any]]]\"\n        \"__len__\" is not present\n  ...",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 49,
-      "startLine": 820
+      "startLine": 823
     },
     {
       "endCharacter": 64,
-      "endLine": 821,
+      "endLine": 824,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "No overloads for \"__call__\" match the provided arguments",
       "rule": "reportCallIssue",
       "severity": "error",
       "startCharacter": 39,
-      "startLine": 821
+      "startLine": 824
     },
     {
       "endCharacter": 55,
-      "endLine": 821,
+      "endLine": 824,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"x1\" of type \"ArrayLike\" in function \"__call__\"\n  Type \"Series[Any] | None\" is not assignable to type \"ArrayLike\"\n    Type \"None\" is not assignable to type \"ArrayLike\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"_SupportsArray[dtype[Any]]\"\n        \"__array__\" is not present\n      \"None\" is incompatible with protocol \"_NestedSequence[_SupportsArray[dtype[Any]]]\"\n        \"__len__\" is not present\n  ...",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 50,
-      "startLine": 821
+      "startLine": 824
     },
     {
       "endCharacter": 63,
-      "endLine": 821,
+      "endLine": 824,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"x2\" of type \"ArrayLike\" in function \"__call__\"\n  Type \"Series[Any] | None\" is not assignable to type \"ArrayLike\"\n    Type \"None\" is not assignable to type \"ArrayLike\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"_SupportsArray[dtype[Any]]\"\n        \"__array__\" is not present\n      \"None\" is incompatible with protocol \"_NestedSequence[_SupportsArray[dtype[Any]]]\"\n        \"__len__\" is not present\n  ...",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 57,
-      "startLine": 821
+      "startLine": 824
     },
     {
       "endCharacter": 55,
-      "endLine": 829,
+      "endLine": 832,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 49,
-      "startLine": 829
+      "startLine": 832
     },
     {
       "endCharacter": 55,
-      "endLine": 830,
+      "endLine": 833,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 49,
-      "startLine": 830
+      "startLine": 833
     },
     {
       "endCharacter": 55,
-      "endLine": 831,
+      "endLine": 834,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 49,
-      "startLine": 831
+      "startLine": 834
     },
     {
       "endCharacter": 55,
-      "endLine": 832,
+      "endLine": 835,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 49,
-      "startLine": 832
+      "startLine": 835
     },
     {
       "endCharacter": 55,
-      "endLine": 833,
+      "endLine": 836,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 49,
-      "startLine": 833
+      "startLine": 836
     },
     {
       "endCharacter": 55,
-      "endLine": 834,
+      "endLine": 837,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"p1\" of type \"T@get_distance\" in function \"get_distance\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 49,
-      "startLine": 834
+      "startLine": 837
     },
     {
       "endCharacter": 50,
-      "endLine": 863,
+      "endLine": 866,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"x\" of type \"ConvertibleToInt\" in function \"__new__\"\n  Type \"Any | None\" is not assignable to type \"ConvertibleToInt\"\n    Type \"None\" is not assignable to type \"ConvertibleToInt\"\n      \"None\" is not assignable to \"str\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"SupportsInt\"\n        \"__int__\" is not present\n      \"None\" is incompatible with protocol \"SupportsIndex\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 44,
-      "startLine": 863
+      "startLine": 866
     },
     {
       "endCharacter": 50,
-      "endLine": 863,
+      "endLine": 866,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"x\" of type \"ConvertibleToInt\" in function \"__new__\"\n  Type \"Any | None\" is not assignable to type \"ConvertibleToInt\"\n    Type \"None\" is not assignable to type \"ConvertibleToInt\"\n      \"None\" is not assignable to \"str\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"SupportsInt\"\n        \"__int__\" is not present\n      \"None\" is incompatible with protocol \"SupportsIndex\"\n  ...",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 44,
-      "startLine": 863
+      "startLine": 866
     },
     {
       "endCharacter": 29,
-      "endLine": 864,
+      "endLine": 867,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"x\" of type \"ConvertibleToInt\" in function \"__new__\"\n  Type \"Any | None\" is not assignable to type \"ConvertibleToInt\"\n    Type \"None\" is not assignable to type \"ConvertibleToInt\"\n      \"None\" is not assignable to \"str\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"SupportsInt\"\n        \"__int__\" is not present\n      \"None\" is incompatible with protocol \"SupportsIndex\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 23,
-      "startLine": 864
+      "startLine": 867
     },
     {
       "endCharacter": 29,
-      "endLine": 864,
+      "endLine": 867,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"x\" of type \"ConvertibleToInt\" in function \"__new__\"\n  Type \"Any | None\" is not assignable to type \"ConvertibleToInt\"\n    Type \"None\" is not assignable to type \"ConvertibleToInt\"\n      \"None\" is not assignable to \"str\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"SupportsInt\"\n        \"__int__\" is not present\n      \"None\" is incompatible with protocol \"SupportsIndex\"\n  ...",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 23,
-      "startLine": 864
+      "startLine": 867
     },
     {
       "endCharacter": 60,
-      "endLine": 901,
+      "endLine": 904,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"x\" of type \"ConvertibleToFloat\" in function \"__new__\"\n  Type \"Any | None\" is not assignable to type \"ConvertibleToFloat\"\n    Type \"None\" is not assignable to type \"ConvertibleToFloat\"\n      \"None\" is not assignable to \"str\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"SupportsFloat\"\n        \"__float__\" is not present\n      \"None\" is incompatible with protocol \"SupportsIndex\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 50,
-      "startLine": 901
+      "startLine": 904
     },
     {
       "endCharacter": 60,
-      "endLine": 901,
+      "endLine": 904,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"x\" of type \"ConvertibleToFloat\" in function \"__new__\"\n  Type \"Any | None\" is not assignable to type \"ConvertibleToFloat\"\n    Type \"None\" is not assignable to type \"ConvertibleToFloat\"\n      \"None\" is not assignable to \"str\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"SupportsFloat\"\n        \"__float__\" is not present\n      \"None\" is incompatible with protocol \"SupportsIndex\"\n  ...",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 50,
-      "startLine": 901
+      "startLine": 904
     },
     {
       "endCharacter": 35,
-      "endLine": 902,
+      "endLine": 905,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"x\" of type \"ConvertibleToFloat\" in function \"__new__\"\n  Type \"Any | None\" is not assignable to type \"ConvertibleToFloat\"\n    Type \"None\" is not assignable to type \"ConvertibleToFloat\"\n      \"None\" is not assignable to \"str\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"SupportsFloat\"\n        \"__float__\" is not present\n      \"None\" is incompatible with protocol \"SupportsIndex\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 25,
-      "startLine": 902
+      "startLine": 905
     },
     {
       "endCharacter": 35,
-      "endLine": 902,
+      "endLine": 905,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"x\" of type \"ConvertibleToFloat\" in function \"__new__\"\n  Type \"Any | None\" is not assignable to type \"ConvertibleToFloat\"\n    Type \"None\" is not assignable to type \"ConvertibleToFloat\"\n      \"None\" is not assignable to \"str\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"SupportsFloat\"\n        \"__float__\" is not present\n      \"None\" is incompatible with protocol \"SupportsIndex\"\n  ...",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 25,
-      "startLine": 902
+      "startLine": 905
     },
     {
       "endCharacter": 41,
-      "endLine": 1127,
+      "endLine": 1130,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"<\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 1127
+      "startLine": 1130
     },
     {
       "endCharacter": 41,
-      "endLine": 1137,
+      "endLine": 1140,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \">\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 1137
+      "startLine": 1140
     },
     {
       "endCharacter": 66,
-      "endLine": 1150,
+      "endLine": 1153,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"timeframe\" of type \"str\" in function \"timeframe_to_prev_date\"\n  Type \"Any | None\" is not assignable to type \"str\"\n    \"None\" is not assignable to \"str\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 38,
-      "startLine": 1150
+      "startLine": 1153
     },
     {
       "endCharacter": 70,
-      "endLine": 1281,
+      "endLine": 1284,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Expected 1 more positional argument",
       "rule": "reportCallIssue",
       "severity": "error",
       "startCharacter": 48,
-      "startLine": 1281
+      "startLine": 1284
     },
     {
       "endCharacter": 74,
-      "endLine": 1345,
+      "endLine": 1348,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"int | None\" cannot be assigned to parameter \"trade_duration_candles\" of type \"int\" in function \"get_trade_natr\"\n  Type \"int | None\" is not assignable to type \"int\"\n    \"None\" is not assignable to \"int\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 52,
-      "startLine": 1345
+      "startLine": 1348
     },
     {
       "endCharacter": 74,
-      "endLine": 1372,
+      "endLine": 1375,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"int | None\" cannot be assigned to parameter \"trade_duration_candles\" of type \"int\" in function \"get_trade_natr\"\n  Type \"int | None\" is not assignable to type \"int\"\n    \"None\" is not assignable to \"int\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 52,
-      "startLine": 1372
+      "startLine": 1375
     },
     {
       "endCharacter": 96,
-      "endLine": 1424,
+      "endLine": 1427,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"timeframe\" of type \"str\" in function \"get_analyzed_dataframe\"\n  Type \"Any | None\" is not assignable to type \"str\"\n    \"None\" is not assignable to \"str\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 68,
-      "startLine": 1424
+      "startLine": 1427
     },
     {
       "endCharacter": 77,
-      "endLine": 1458,
+      "endLine": 1461,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"<=\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 57,
-      "startLine": 1458
+      "startLine": 1461
     },
     {
       "endCharacter": 9,
-      "endLine": 1463,
+      "endLine": 1466,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"+\" not supported for types \"float\" and \"float | None\"\n  Operator \"+\" not supported for types \"float\" and \"None\"",
       "rule": "reportOperatorIssue",
       "severity": "error",
       "startCharacter": 28,
-      "startLine": 1461
+      "startLine": 1464
     },
     {
       "endCharacter": 33,
-      "endLine": 1462,
+      "endLine": 1465,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"-\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 13,
-      "startLine": 1462
+      "startLine": 1465
     },
     {
       "endCharacter": 67,
-      "endLine": 1468,
+      "endLine": 1471,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"float | None\" cannot be assigned to parameter \"x\" of type \"ConvertibleToFloat\" in function \"__new__\"\n  Type \"float | None\" is not assignable to type \"ConvertibleToFloat\"\n    Type \"None\" is not assignable to type \"ConvertibleToFloat\"\n      \"None\" is not assignable to \"str\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"SupportsFloat\"\n        \"__float__\" is not present\n      \"None\" is incompatible with protocol \"SupportsIndex\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 47,
-      "startLine": 1468
+      "startLine": 1471
     },
     {
       "endCharacter": 67,
-      "endLine": 1468,
+      "endLine": 1471,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"float | None\" cannot be assigned to parameter \"x\" of type \"ConvertibleToFloat\" in function \"__new__\"\n  Type \"float | None\" is not assignable to type \"ConvertibleToFloat\"\n    Type \"None\" is not assignable to type \"ConvertibleToFloat\"\n      \"None\" is not assignable to \"str\"\n      \"None\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"None\" is incompatible with protocol \"SupportsFloat\"\n        \"__float__\" is not present\n      \"None\" is incompatible with protocol \"SupportsIndex\"\n  ...",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 47,
-      "startLine": 1468
+      "startLine": 1471
     },
     {
       "endCharacter": 64,
-      "endLine": 1622,
+      "endLine": 1625,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "\"isoformat\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 55,
-      "startLine": 1622
+      "startLine": 1625
     },
     {
       "endCharacter": 37,
-      "endLine": 1673,
+      "endLine": 1676,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"<=\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 15,
-      "startLine": 1673
+      "startLine": 1676
     },
     {
       "endCharacter": 48,
-      "endLine": 1675,
+      "endLine": 1678,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"<=\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 15,
-      "startLine": 1675
+      "startLine": 1678
     },
     {
       "endCharacter": 96,
-      "endLine": 1855,
+      "endLine": 1858,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"timeframe\" of type \"str\" in function \"get_analyzed_dataframe\"\n  Type \"Any | None\" is not assignable to type \"str\"\n    \"None\" is not assignable to \"str\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 68,
-      "startLine": 1855
+      "startLine": 1858
     },
     {
       "endCharacter": 39,
-      "endLine": 1932,
+      "endLine": 1935,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"+\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 21,
-      "startLine": 1932
+      "startLine": 1935
     },
     {
       "endCharacter": 90,
-      "endLine": 1932,
+      "endLine": 1935,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"*\" not supported for types \"float\" and \"Any | None\"\n  Operator \"*\" not supported for types \"float\" and \"None\"",
       "rule": "reportOperatorIssue",
       "severity": "error",
       "startCharacter": 62,
-      "startLine": 1932
+      "startLine": 1935
     },
     {
       "endCharacter": 96,
-      "endLine": 2236,
+      "endLine": 2239,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"timeframe\" of type \"str\" in function \"get_analyzed_dataframe\"\n  Type \"Any | None\" is not assignable to type \"str\"\n    \"None\" is not assignable to \"str\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 68,
-      "startLine": 2236
+      "startLine": 2239
     },
     {
       "endCharacter": 85,
-      "endLine": 2261,
+      "endLine": 2264,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "\"isoformat\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 76,
-      "startLine": 2261
+      "startLine": 2264
     },
     {
       "endCharacter": 47,
-      "endLine": 2267,
+      "endLine": 2270,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \"<\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2267
+      "startLine": 2270
     },
     {
       "endCharacter": 42,
-      "endLine": 2271,
+      "endLine": 2274,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"str\" cannot be assigned to parameter \"side\" of type \"TradeDirection\" in function \"reversal_confirmed\"\n  Type \"str\" is not assignable to type \"TradeDirection\"\n    \"str\" is not assignable to type \"Literal['long']\"\n    \"str\" is not assignable to type \"Literal['short']\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2271
+      "startLine": 2274
     },
     {
       "endCharacter": 42,
-      "endLine": 2272,
+      "endLine": 2275,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"str\" cannot be assigned to parameter \"order\" of type \"OrderType\" in function \"reversal_confirmed\"\n  Type \"str\" is not assignable to type \"OrderType\"\n    \"str\" is not assignable to type \"Literal['entry']\"\n    \"str\" is not assignable to type \"Literal['exit']\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2272
+      "startLine": 2275
     },
     {
       "endCharacter": 69,
-      "endLine": 2274,
+      "endLine": 2277,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"int | float\" cannot be assigned to parameter \"lookback_period_candles\" of type \"int\" in function \"reversal_confirmed\"\n  Type \"int | float\" is not assignable to type \"int\"\n    \"float\" is not assignable to \"int\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2274
+      "startLine": 2277
     },
     {
       "endCharacter": 47,
-      "endLine": 2285,
+      "endLine": 2288,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Operator \">\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2285
+      "startLine": 2288
     },
     {
       "endCharacter": 43,
-      "endLine": 2289,
+      "endLine": 2292,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"str\" cannot be assigned to parameter \"side\" of type \"TradeDirection\" in function \"reversal_confirmed\"\n  Type \"str\" is not assignable to type \"TradeDirection\"\n    \"str\" is not assignable to type \"Literal['long']\"\n    \"str\" is not assignable to type \"Literal['short']\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2289
+      "startLine": 2292
     },
     {
       "endCharacter": 42,
-      "endLine": 2290,
+      "endLine": 2293,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"str\" cannot be assigned to parameter \"order\" of type \"OrderType\" in function \"reversal_confirmed\"\n  Type \"str\" is not assignable to type \"OrderType\"\n    \"str\" is not assignable to type \"Literal['entry']\"\n    \"str\" is not assignable to type \"Literal['exit']\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2290
+      "startLine": 2293
     },
     {
       "endCharacter": 69,
-      "endLine": 2292,
+      "endLine": 2295,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"int | float\" cannot be assigned to parameter \"lookback_period_candles\" of type \"int\" in function \"reversal_confirmed\"\n  Type \"int | float\" is not assignable to type \"int\"\n    \"float\" is not assignable to \"int\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2292
+      "startLine": 2295
     },
     {
       "endCharacter": 52,
-      "endLine": 2321,
+      "endLine": 2324,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"datetime | None\" cannot be assigned to parameter \"current_candle_date\" of type \"datetime\" in function \"_normalize_final_take_profit_state\"\n  Type \"datetime | None\" is not assignable to type \"datetime\"\n    \"None\" is not assignable to \"datetime\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 36,
-      "startLine": 2321
+      "startLine": 2324
     },
     {
       "endCharacter": 96,
-      "endLine": 2441,
+      "endLine": 2444,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"Any | None\" cannot be assigned to parameter \"timeframe\" of type \"str\" in function \"get_analyzed_dataframe\"\n  Type \"Any | None\" is not assignable to type \"str\"\n    \"None\" is not assignable to \"str\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 68,
-      "startLine": 2441
+      "startLine": 2444
     },
     {
       "endCharacter": 43,
-      "endLine": 2450,
+      "endLine": 2453,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"str\" cannot be assigned to parameter \"order\" of type \"OrderType\" in function \"reversal_confirmed\"\n  Type \"str\" is not assignable to type \"OrderType\"\n    \"str\" is not assignable to type \"Literal['entry']\"\n    \"str\" is not assignable to type \"Literal['exit']\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2450
+      "startLine": 2453
     },
     {
       "endCharacter": 69,
-      "endLine": 2452,
+      "endLine": 2455,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"int | float\" cannot be assigned to parameter \"lookback_period_candles\" of type \"int\" in function \"reversal_confirmed\"\n  Type \"int | float\" is not assignable to type \"int\"\n    \"float\" is not assignable to \"int\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 2452
+      "startLine": 2455
     },
     {
       "endCharacter": 32,
-      "endLine": 2528,
+      "endLine": 2531,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"LocalTrade\" cannot be assigned to parameter \"trade\" of type \"Trade\" in function \"get_trade_annotation_line_start_date\"\n  \"LocalTrade\" is not assignable to \"Trade\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 27,
-      "startLine": 2528
+      "startLine": 2531
     },
     {
       "endCharacter": 72,
-      "endLine": 2531,
+      "endLine": 2534,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"LocalTrade\" cannot be assigned to parameter \"trade\" of type \"Trade\" in function \"get_trade_exit_stage\"\n  \"LocalTrade\" is not assignable to \"Trade\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 67,
-      "startLine": 2531
+      "startLine": 2534
     },
     {
       "endCharacter": 36,
-      "endLine": 2538,
+      "endLine": 2541,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"LocalTrade\" cannot be assigned to parameter \"trade\" of type \"Trade\" in function \"get_take_profit_target\"\n  \"LocalTrade\" is not assignable to \"Trade\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 31,
-      "startLine": 2538
+      "startLine": 2541
     },
     {
       "endCharacter": 71,
-      "endLine": 2569,
+      "endLine": 2572,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"LocalTrade\" cannot be assigned to parameter \"trade\" of type \"Trade\" in function \"get_trade_entry_date\"\n  \"LocalTrade\" is not assignable to \"Trade\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 66,
-      "startLine": 2569
+      "startLine": 2572
     },
     {
       "endCharacter": 32,
-      "endLine": 2600,
+      "endLine": 2603,
       "file": "quickadapter/user_data/strategies/QuickAdapterV3.py",
       "message": "Argument of type \"LocalTrade\" cannot be assigned to parameter \"trade\" of type \"Trade\" in function \"get_take_profit_target\"\n  \"LocalTrade\" is not assignable to \"Trade\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 27,
-      "startLine": 2600
+      "startLine": 2603
     },
     {
       "endCharacter": 34,
     },
     {
       "endCharacter": 78,
-      "endLine": 890,
+      "endLine": 892,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Type \"tuple[SmoothingMethod, ...]\" is not assignable to declared type \"tuple[SmoothingKernel, ...]\"\n  \"tuple[SmoothingMethod, ...]\" is not assignable to \"tuple[SmoothingKernel, ...]\"\n    Tuple entry 1 is incorrect type\n      Type \"SmoothingMethod\" is not assignable to type \"SmoothingKernel\"\n        Type \"Literal['gaussian_filter1d']\" is not assignable to type \"SmoothingKernel\"\n          \"Literal['gaussian_filter1d']\" is not assignable to type \"Literal['gaussian']\"\n          \"Literal['gaussian_filter1d']\" is not assignable to type \"Literal['kaiser']\"\n          \"Literal['gaussian_filter1d']\" is not assignable to type \"Literal['kaiser_bessel_derived']\"\n          \"Literal['gaussian_filter1d']\" is not assignable to type \"Literal['triang']\"",
       "rule": "reportAssignmentType",
       "severity": "error",
       "startCharacter": 56,
-      "startLine": 890
+      "startLine": 892
     },
     {
       "endCharacter": 98,
-      "endLine": 1627,
+      "endLine": 1633,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Type \"bool | bool_\" is not assignable to return type \"bool\"\n  Type \"bool | bool_\" is not assignable to type \"bool\"\n    \"numpy.bool[builtins.bool]\" is not assignable to \"bool\"",
       "rule": "reportReturnType",
       "severity": "error",
       "startCharacter": 15,
-      "startLine": 1627
+      "startLine": 1633
     },
     {
       "endCharacter": 33,
-      "endLine": 1657,
+      "endLine": 1663,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"Scalar\" cannot be assigned to parameter \"x\" of type \"ConvertibleToInt\" in function \"__new__\"\n  Type \"Scalar\" is not assignable to type \"ConvertibleToInt\"\n    Type \"complex\" is not assignable to type \"ConvertibleToInt\"\n      \"complex\" is not assignable to \"str\"\n      \"complex\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"complex\" is incompatible with protocol \"SupportsInt\"\n        \"__int__\" is not present\n      \"complex\" is incompatible with protocol \"SupportsIndex\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 1657
+      "startLine": 1663
     },
     {
       "endCharacter": 33,
-      "endLine": 1657,
+      "endLine": 1663,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"Scalar\" cannot be assigned to parameter \"x\" of type \"ConvertibleToInt\" in function \"__new__\"\n  Type \"Scalar\" is not assignable to type \"ConvertibleToInt\"\n    Type \"complex\" is not assignable to type \"ConvertibleToInt\"\n      \"complex\" is not assignable to \"str\"\n      \"complex\" is incompatible with protocol \"Buffer\"\n        \"__buffer__\" is not present\n      \"complex\" is incompatible with protocol \"SupportsInt\"\n        \"__int__\" is not present\n      \"complex\" is incompatible with protocol \"SupportsIndex\"\n  ...",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 1657
+      "startLine": 1663
     },
     {
       "endCharacter": 23,
-      "endLine": 1669,
+      "endLine": 1675,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Type \"float\" is not assignable to return type \"T@get_distance\"\n  Type \"float\" is not assignable to type \"T@get_distance\"",
       "rule": "reportReturnType",
       "severity": "error",
       "startCharacter": 11,
-      "startLine": 1669
+      "startLine": 1675
     },
     {
       "endCharacter": 83,
-      "endLine": 2524,
+      "endLine": 2530,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"str\" cannot be assigned to parameter \"key\" of type \"CombinedMetric\" in function \"__getitem__\"\n  Type \"str\" is not assignable to type \"CombinedMetric\"\n    \"str\" is not assignable to type \"Literal['amplitude']\"\n    \"str\" is not assignable to type \"Literal['amplitude_threshold_ratio']\"\n    \"str\" is not assignable to type \"Literal['volume_rate']\"\n    \"str\" is not assignable to type \"Literal['speed']\"\n    \"str\" is not assignable to type \"Literal['efficiency_ratio']\"\n    \"str\" is not assignable to type \"Literal['volume_weighted_efficiency_ratio']\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 58,
-      "startLine": 2524
+      "startLine": 2530
     },
     {
       "endCharacter": 38,
-      "endLine": 3414,
+      "endLine": 3420,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Cannot access attribute \"__func__\" for class \"FunctionType\"\n  Attribute \"__func__\" is unknown",
       "rule": "reportFunctionMemberAccess",
       "severity": "error",
       "startCharacter": 30,
-      "startLine": 3414
+      "startLine": 3420
     },
     {
       "endCharacter": 34,
-      "endLine": 3416,
+      "endLine": 3422,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Cannot access attribute \"__func__\" for class \"FunctionType\"\n  Attribute \"__func__\" is unknown",
       "rule": "reportFunctionMemberAccess",
       "severity": "error",
       "startCharacter": 26,
-      "startLine": 3416
+      "startLine": 3422
     },
     {
       "endCharacter": 55,
-      "endLine": 3644,
+      "endLine": 3652,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"rolling\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 48,
-      "startLine": 3644
+      "startLine": 3652
     },
     {
       "endCharacter": 38,
-      "endLine": 3669,
+      "endLine": 3677,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"rolling\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 31,
-      "startLine": 3669
+      "startLine": 3677
     },
     {
       "endCharacter": 55,
-      "endLine": 3695,
+      "endLine": 3703,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"rolling\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 48,
-      "startLine": 3695
+      "startLine": 3703
     },
     {
       "endCharacter": 56,
-      "endLine": 3696,
+      "endLine": 3704,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"rolling\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 49,
-      "startLine": 3696
+      "startLine": 3704
     },
     {
       "endCharacter": 33,
-      "endLine": 3768,
+      "endLine": 3776,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"Series[Any] | NDArray[floating[Any]]\" cannot be assigned to parameter \"series\" of type \"Series[Any]\" in function \"calculate_zero_lag\"\n  Type \"Series[Any] | NDArray[floating[Any]]\" is not assignable to type \"Series[Any]\"\n    \"ndarray[_AnyShape, dtype[floating[Any]]]\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 27,
-      "startLine": 3768
+      "startLine": 3776
     },
     {
       "endCharacter": 69,
-      "endLine": 3768,
+      "endLine": 3776,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Expected 1 more positional argument",
       "rule": "reportCallIssue",
       "severity": "error",
       "startCharacter": 59,
-      "startLine": 3768
+      "startLine": 3776
     },
     {
       "endCharacter": 40,
-      "endLine": 3823,
+      "endLine": 3831,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"series\" of type \"Series[Any]\" in function \"calculate_zero_lag\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 35,
-      "startLine": 3823
+      "startLine": 3831
     },
     {
       "endCharacter": 38,
-      "endLine": 3824,
+      "endLine": 3832,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"series\" of type \"Series[Any]\" in function \"calculate_zero_lag\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 34,
-      "startLine": 3824
+      "startLine": 3832
     },
     {
       "endCharacter": 42,
-      "endLine": 3825,
+      "endLine": 3833,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"Series[Any] | None\" cannot be assigned to parameter \"series\" of type \"Series[Any]\" in function \"calculate_zero_lag\"\n  Type \"Series[Any] | None\" is not assignable to type \"Series[Any]\"\n    \"None\" is not assignable to \"Series[Any]\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 36,
-      "startLine": 3825
+      "startLine": 3833
     },
     {
       "endCharacter": 45,
-      "endLine": 3827,
+      "endLine": 3835,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"index\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 40,
-      "startLine": 3827
+      "startLine": 3835
     },
     {
       "endCharacter": 33,
-      "endLine": 3829,
+      "endLine": 3837,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"iloc\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 29,
-      "startLine": 3829
+      "startLine": 3837
     },
     {
       "endCharacter": 31,
-      "endLine": 3830,
+      "endLine": 3838,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"iloc\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 27,
-      "startLine": 3830
+      "startLine": 3838
     },
     {
       "endCharacter": 48,
-      "endLine": 3835,
+      "endLine": 3843,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"index\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 43,
-      "startLine": 3835
+      "startLine": 3843
     },
     {
       "endCharacter": 40,
-      "endLine": 3836,
+      "endLine": 3844,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"iloc\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 36,
-      "startLine": 3836
+      "startLine": 3844
     },
     {
       "endCharacter": 59,
-      "endLine": 3838,
+      "endLine": 3846,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Cannot access attribute \"iloc\" for class \"NDArray[Any]\"\n  Attribute \"iloc\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 55,
-      "startLine": 3838
+      "startLine": 3846
     },
     {
       "endCharacter": 34,
-      "endLine": 3840,
+      "endLine": 3848,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Cannot access attribute \"iloc\" for class \"NDArray[Any]\"\n  Attribute \"iloc\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 30,
-      "startLine": 3840
+      "startLine": 3848
     },
     {
       "endCharacter": 51,
-      "endLine": 3840,
+      "endLine": 3848,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"iloc\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 47,
-      "startLine": 3840
+      "startLine": 3848
     },
     {
       "endCharacter": 72,
-      "endLine": 3840,
+      "endLine": 3848,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Cannot access attribute \"iloc\" for class \"NDArray[Any]\"\n  Attribute \"iloc\" is unknown",
       "rule": "reportAttributeAccessIssue",
       "severity": "error",
       "startCharacter": 68,
-      "startLine": 3840
+      "startLine": 3848
     },
     {
       "endCharacter": 40,
-      "endLine": 3907,
+      "endLine": 3915,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Type \"(Series[Any] | NDArray[floating[Any]], int) -> (Series[Any] | NDArray[floating[Any]])\" is not assignable to declared type \"(series: Unknown, timeperiod: Unknown) -> Series[Any]\"\n  Type \"(Series[Any] | NDArray[floating[Any]], int) -> (Series[Any] | NDArray[floating[Any]])\" is not assignable to type \"(series: Unknown, timeperiod: Unknown) -> Series[Any]\"\n    Missing keyword parameter \"series\"\n    Missing keyword parameter \"timeperiod\"\n      Position-only parameter mismatch; parameter \"series\" is not position-only\n      Position-only parameter mismatch; parameter \"timeperiod\" is not position-only\n      Position-only parameter mismatch; expected 2 but received 0\n      Function return type \"Series[Any] | NDArray[floating[Any]]\" is incompatible with type \"Series[Any]\"\n        Type \"Series[Any] | NDArray[floating[Any]]\" is not assignable to type \"Series[Any]\"\n  ...",
       "rule": "reportAssignmentType",
       "severity": "error",
       "startCharacter": 20,
-      "startLine": 3907
+      "startLine": 3915
     },
     {
       "endCharacter": 33,
-      "endLine": 3909,
+      "endLine": 3917,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Type \"(Series[Any] | NDArray[floating[Any]], int) -> (Series[Any] | NDArray[floating[Any]])\" is not assignable to declared type \"(series: Unknown, timeperiod: Unknown) -> Series[Any]\"\n  Type \"(Series[Any] | NDArray[floating[Any]], int) -> (Series[Any] | NDArray[floating[Any]])\" is not assignable to type \"(series: Unknown, timeperiod: Unknown) -> Series[Any]\"\n    Missing keyword parameter \"series\"\n    Missing keyword parameter \"timeperiod\"\n      Position-only parameter mismatch; parameter \"series\" is not position-only\n      Position-only parameter mismatch; parameter \"timeperiod\" is not position-only\n      Position-only parameter mismatch; expected 2 but received 0\n      Function return type \"Series[Any] | NDArray[floating[Any]]\" is incompatible with type \"Series[Any]\"\n        Type \"Series[Any] | NDArray[floating[Any]]\" is not assignable to type \"Series[Any]\"\n  ...",
       "rule": "reportAssignmentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 3909
+      "startLine": 3917
     },
     {
       "endCharacter": 35,
-      "endLine": 3955,
+      "endLine": 3963,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"to_numpy\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 27,
-      "startLine": 3955
+      "startLine": 3963
     },
     {
       "endCharacter": 33,
-      "endLine": 3956,
+      "endLine": 3964,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"to_numpy\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 25,
-      "startLine": 3956
+      "startLine": 3964
     },
     {
       "endCharacter": 37,
-      "endLine": 4068,
+      "endLine": 4076,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"to_numpy\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 29,
-      "startLine": 4068
+      "startLine": 4076
     },
     {
       "endCharacter": 35,
-      "endLine": 4069,
+      "endLine": 4077,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"to_numpy\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 27,
-      "startLine": 4069
+      "startLine": 4077
     },
     {
       "endCharacter": 33,
-      "endLine": 4070,
+      "endLine": 4078,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"to_numpy\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 25,
-      "startLine": 4070
+      "startLine": 4078
     },
     {
       "endCharacter": 39,
-      "endLine": 4090,
+      "endLine": 4098,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"to_numpy\" is not a known attribute of \"None\"",
       "rule": "reportOptionalMemberAccess",
       "severity": "error",
       "startCharacter": 31,
-      "startLine": 4090
+      "startLine": 4098
     },
     {
       "endCharacter": 92,
-      "endLine": 4449,
+      "endLine": 4457,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Type \"bool_ | bool\" is not assignable to return type \"bool\"\n  Type \"bool_ | bool\" is not assignable to type \"bool\"\n    \"numpy.bool[builtins.bool]\" is not assignable to \"bool\"",
       "rule": "reportReturnType",
       "severity": "error",
       "startCharacter": 15,
-      "startLine": 4449
+      "startLine": 4457
     },
     {
       "endCharacter": 85,
-      "endLine": 4850,
+      "endLine": 4858,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"XGBoostPruningCallback\" cannot be assigned to parameter \"object\" of type \"RegressorCallback\" in function \"append\"\n  Type \"XGBoostPruningCallback\" is not assignable to type \"RegressorCallback\"\n    Type \"XGBoostPruningCallback\" is not assignable to type \"(...) -> Any\"\n    \"XGBoostPruningCallback\" is not assignable to \"TrainingCallback\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 16,
-      "startLine": 4850
+      "startLine": 4858
     },
     {
       "endCharacter": 29,
-      "endLine": 4893,
+      "endLine": 4901,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"list[tuple[DataFrame, DataFrame]] | None\" cannot be assigned to parameter \"eval_set\" of type \"List[_LGBM_ScikitValidSet] | None\" in function \"fit\"\n  Type \"list[tuple[DataFrame, DataFrame]] | None\" is not assignable to type \"List[_LGBM_ScikitValidSet] | None\"\n    Type \"list[tuple[DataFrame, DataFrame]]\" is not assignable to type \"List[_LGBM_ScikitValidSet] | None\"\n      \"list[tuple[DataFrame, DataFrame]]\" is not assignable to \"List[_LGBM_ScikitValidSet]\"\n        Type parameter \"_T@list\" is invariant, but \"tuple[DataFrame, DataFrame]\" is not the same as \"_LGBM_ScikitValidSet\"\n        Consider switching from \"list\" to \"Sequence\" which is covariant\n      \"list[tuple[DataFrame, DataFrame]]\" is not assignable to \"None\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 21,
-      "startLine": 4893
+      "startLine": 4901
     },
     {
       "endCharacter": 43,
-      "endLine": 4894,
+      "endLine": 4902,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"list[NDArray[floating[Any]]] | None\" cannot be assigned to parameter \"eval_sample_weight\" of type \"List[_LGBM_WeightType] | None\" in function \"fit\"\n  Type \"list[NDArray[floating[Any]]] | None\" is not assignable to type \"List[_LGBM_WeightType] | None\"\n    Type \"list[NDArray[floating[Any]]]\" is not assignable to type \"List[_LGBM_WeightType] | None\"\n      \"list[NDArray[floating[Any]]]\" is not assignable to \"List[_LGBM_WeightType]\"\n        Type parameter \"_T@list\" is invariant, but \"NDArray[floating[Any]]\" is not the same as \"_LGBM_WeightType\"\n        Consider switching from \"list\" to \"Sequence\" which is covariant\n      \"list[NDArray[floating[Any]]]\" is not assignable to \"None\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 31,
-      "startLine": 4894
+      "startLine": 4902
     },
     {
       "endCharacter": 62,
-      "endLine": 4897,
+      "endLine": 4905,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"list[RegressorCallback] | None\" cannot be assigned to parameter \"callbacks\" of type \"List[(...) -> Unknown] | None\" in function \"fit\"\n  Type \"list[RegressorCallback] | None\" is not assignable to type \"List[(...) -> Unknown] | None\"\n    Type \"list[RegressorCallback]\" is not assignable to type \"List[(...) -> Unknown] | None\"\n      \"list[RegressorCallback]\" is not assignable to \"List[(...) -> Unknown]\"\n        Type parameter \"_T@list\" is invariant, but \"RegressorCallback\" is not the same as \"(...) -> Unknown\"\n        Consider switching from \"list\" to \"Sequence\" which is covariant\n      \"list[RegressorCallback]\" is not assignable to \"None\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 22,
-      "startLine": 4897
+      "startLine": 4905
     },
     {
       "endCharacter": 35,
-      "endLine": 4919,
+      "endLine": 4927,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Object of type \"None\" is not subscriptable",
       "rule": "reportOptionalSubscript",
       "severity": "error",
       "startCharacter": 27,
-      "startLine": 4919
+      "startLine": 4927
     },
     {
       "endCharacter": 35,
-      "endLine": 4965,
+      "endLine": 4973,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Object of type \"None\" is not subscriptable",
       "rule": "reportOptionalSubscript",
       "severity": "error",
       "startCharacter": 27,
-      "startLine": 4965
+      "startLine": 4973
     },
     {
       "endCharacter": 49,
-      "endLine": 5035,
+      "endLine": 5043,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Argument of type \"CatBoostPruningCallback\" cannot be assigned to parameter \"object\" of type \"RegressorCallback\" in function \"append\"\n  Type \"CatBoostPruningCallback\" is not assignable to type \"RegressorCallback\"\n    Type \"CatBoostPruningCallback\" is not assignable to type \"(...) -> Any\"\n    \"CatBoostPruningCallback\" is not assignable to \"TrainingCallback\"",
       "rule": "reportArgumentType",
       "severity": "error",
       "startCharacter": 33,
-      "startLine": 5035
+      "startLine": 5043
     },
     {
       "endCharacter": 75,
-      "endLine": 5278,
+      "endLine": 5286,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Operator \"<=\" not supported for \"None\"",
       "rule": "reportOptionalOperand",
       "severity": "error",
       "startCharacter": 54,
-      "startLine": 5278
+      "startLine": 5286
     },
     {
       "endCharacter": 23,
-      "endLine": 5441,
+      "endLine": 5449,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"best_params\" is possibly unbound",
       "rule": "reportPossiblyUnboundVariable",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 5441
+      "startLine": 5449
     },
     {
       "endCharacter": 38,
-      "endLine": 5448,
+      "endLine": 5456,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"best_params\" is possibly unbound",
       "rule": "reportPossiblyUnboundVariable",
       "severity": "error",
       "startCharacter": 27,
-      "startLine": 5448
+      "startLine": 5456
     },
     {
       "endCharacter": 22,
-      "endLine": 5460,
+      "endLine": 5468,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "\"best_params\" is possibly unbound",
       "rule": "reportPossiblyUnboundVariable",
       "severity": "error",
       "startCharacter": 11,
-      "startLine": 5460
+      "startLine": 5468
     },
     {
       "endCharacter": 22,
-      "endLine": 5618,
+      "endLine": 5626,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Declaration \"default_ranges\" is obscured by a declaration of the same name",
       "rule": "reportRedeclaration",
       "severity": "error",
       "startCharacter": 8,
-      "startLine": 5618
+      "startLine": 5626
     },
     {
       "endCharacter": 14,
-      "endLine": 5654,
+      "endLine": 5662,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Declaration \"params\" is obscured by a declaration of the same name",
       "rule": "reportRedeclaration",
       "severity": "error",
       "startCharacter": 8,
-      "startLine": 5654
+      "startLine": 5662
     },
     {
       "endCharacter": 22,
-      "endLine": 5738,
+      "endLine": 5746,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Declaration \"default_ranges\" is obscured by a declaration of the same name",
       "rule": "reportRedeclaration",
       "severity": "error",
       "startCharacter": 8,
-      "startLine": 5738
+      "startLine": 5746
     },
     {
       "endCharacter": 14,
-      "endLine": 5772,
+      "endLine": 5780,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Declaration \"params\" is obscured by a declaration of the same name",
       "rule": "reportRedeclaration",
       "severity": "error",
       "startCharacter": 8,
-      "startLine": 5772
+      "startLine": 5780
     },
     {
       "endCharacter": 22,
-      "endLine": 5843,
+      "endLine": 5851,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Declaration \"default_ranges\" is obscured by a declaration of the same name",
       "rule": "reportRedeclaration",
       "severity": "error",
       "startCharacter": 8,
-      "startLine": 5843
+      "startLine": 5851
     },
     {
       "endCharacter": 22,
-      "endLine": 5944,
+      "endLine": 5952,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Declaration \"default_ranges\" is obscured by a declaration of the same name",
       "rule": "reportRedeclaration",
       "severity": "error",
       "startCharacter": 8,
-      "startLine": 5944
+      "startLine": 5952
     },
     {
       "endCharacter": 26,
-      "endLine": 6027,
+      "endLine": 6035,
       "file": "quickadapter/user_data/strategies/Utils.py",
       "message": "Declaration \"default_ranges\" is obscured by a declaration of the same name",
       "rule": "reportRedeclaration",
       "severity": "error",
       "startCharacter": 12,
-      "startLine": 6027
+      "startLine": 6035
     }
   ],
   "filesAnalyzed": 5,
index 2310197f6070a840445d9034e11b431efdd2253a..22e12b6eb509490079aeaaf1a52647df2a07116a 100644 (file)
@@ -72,7 +72,8 @@ from sklearn.preprocessing import (
 )
 from Utils import (
     _CATBOOST_TASK_TYPES,
-    _FORMAT_STYLES,
+    _FORMAT_STYLE_DICT,
+    _FORMAT_STYLE_PARAMS,
     _OPTUNA_LABEL_SELECTION_SCHEMA_VERSION,
     _OPTUNA_NAMESPACES,
     _REGRESSOR_SPECS,
@@ -436,8 +437,8 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         optuna.study.StudyDirection.MAXIMIZE,
     ) * _OPTUNA_LABEL_N_OBJECTIVES
     _OPTUNA_STORAGE_BACKENDS: Final[tuple[str, ...]] = ("file", "sqlite")
-    _STORAGE_FILE: Final[str] = _OPTUNA_STORAGE_BACKENDS[0]
-    _STORAGE_SQLITE: Final[str] = _OPTUNA_STORAGE_BACKENDS[1]
+    _STORAGE_FILE: Final[str] = _OPTUNA_STORAGE_BACKENDS[0]  # "file"
+    _STORAGE_SQLITE: Final[str] = _OPTUNA_STORAGE_BACKENDS[1]  # "sqlite"
 
     _OPTUNA_JOURNAL_QUARANTINE_TAG: Final[str] = "corrupt"
     _OPTUNA_JOURNAL_RECOVERABLE_ERRORS: Final[tuple[type[Exception], ...]] = (
@@ -464,9 +465,9 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         "robust",
     )
     SCALER_DEFAULT: Final[ScalerType] = _SCALER_TYPES[0]  # "minmax"
-    _SCALER_MAXABS: Final[str] = _SCALER_TYPES[1]
-    _SCALER_STANDARD: Final[str] = _SCALER_TYPES[2]
-    _SCALER_ROBUST: Final[str] = _SCALER_TYPES[3]
+    _SCALER_MAXABS: Final[str] = _SCALER_TYPES[1]  # "maxabs"
+    _SCALER_STANDARD: Final[str] = _SCALER_TYPES[2]  # "standard"
+    _SCALER_ROBUST: Final[str] = _SCALER_TYPES[3]  # "robust"
     _SCALER_TYPES_SET: Final[frozenset[ScalerType]] = frozenset(_SCALER_TYPES)
 
     RANGE_DEFAULT: Final[tuple[float, float]] = (-1.0, 1.0)
@@ -475,21 +476,21 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         "compromise_programming",
         "topsis",
     )
-    _METHOD_COMPROMISE_PROGRAMMING: Final[str] = _DISTANCE_METHODS[0]
-    _METHOD_TOPSIS: Final[str] = _DISTANCE_METHODS[1]
+    _METHOD_COMPROMISE_PROGRAMMING: Final[str] = _DISTANCE_METHODS[0]  # "compromise_programming"
+    _METHOD_TOPSIS: Final[str] = _DISTANCE_METHODS[1]  # "topsis"
     _DISTANCE_METHODS_SET: Final[frozenset[DistanceMethod]] = frozenset(_DISTANCE_METHODS)
     _CLUSTER_METHODS: Final[tuple[ClusterMethod, ...]] = (
         "kmeans",
         "kmeans2",
         "kmedoids",
     )
-    _CLUSTER_KMEANS: Final[str] = _CLUSTER_METHODS[0]
-    _CLUSTER_KMEANS2: Final[str] = _CLUSTER_METHODS[1]
-    _CLUSTER_KMEDOIDS: Final[str] = _CLUSTER_METHODS[2]
+    _CLUSTER_KMEANS: Final[str] = _CLUSTER_METHODS[0]  # "kmeans"
+    _CLUSTER_KMEANS2: Final[str] = _CLUSTER_METHODS[1]  # "kmeans2"
+    _CLUSTER_KMEDOIDS: Final[str] = _CLUSTER_METHODS[2]  # "kmedoids"
 
     _DENSITY_METHODS: Final[tuple[DensityMethod, ...]] = ("knn", "medoid")
-    _DENSITY_KNN: Final[str] = _DENSITY_METHODS[0]
-    _DENSITY_MEDOID: Final[str] = _DENSITY_METHODS[1]
+    _DENSITY_KNN: Final[str] = _DENSITY_METHODS[0]  # "knn"
+    _DENSITY_MEDOID: Final[str] = _DENSITY_METHODS[1]  # "medoid"
 
     _SELECTION_CATEGORIES: Final[dict[str, tuple[SelectionMethod, ...]]] = {
         "distance": _DISTANCE_METHODS,
@@ -497,19 +498,21 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         "density": _DENSITY_METHODS,
     }
     _CATEGORY_DISTANCE, _CATEGORY_CLUSTER, _CATEGORY_DENSITY = _SELECTION_CATEGORIES
-    _SUPPORT_POLICY_FALLBACK: Final[Literal["fallback"]] = LABEL_WEIGHT_SUPPORT_POLICIES[0]
-    _SUPPORT_POLICY_RAISE: Final[Literal["raise"]] = LABEL_WEIGHT_SUPPORT_POLICIES[1]
+    _SUPPORT_POLICY_FALLBACK: Final[Literal["fallback"]] = LABEL_WEIGHT_SUPPORT_POLICIES[
+        0
+    ]  # "fallback"
+    _SUPPORT_POLICY_RAISE: Final[Literal["raise"]] = LABEL_WEIGHT_SUPPORT_POLICIES[1]  # "raise"
 
     _SELECTION_METHODS: Final[tuple[SelectionMethod, ...]] = (
         *_DISTANCE_METHODS,
         *_CLUSTER_METHODS,
         *_DENSITY_METHODS,
     )
-    _SELECTION_KMEANS: Final[str] = _SELECTION_METHODS[2]
-    _SELECTION_KMEANS2: Final[str] = _SELECTION_METHODS[3]
-    _SELECTION_KMEDOIDS: Final[str] = _SELECTION_METHODS[4]
-    _SELECTION_KNN: Final[str] = _SELECTION_METHODS[5]
-    _SELECTION_MEDOID: Final[str] = _SELECTION_METHODS[6]
+    _SELECTION_KMEANS: Final[str] = _SELECTION_METHODS[2]  # "kmeans"
+    _SELECTION_KMEANS2: Final[str] = _SELECTION_METHODS[3]  # "kmeans2"
+    _SELECTION_KMEDOIDS: Final[str] = _SELECTION_METHODS[4]  # "kmedoids"
+    _SELECTION_KNN: Final[str] = _SELECTION_METHODS[5]  # "knn"
+    _SELECTION_MEDOID: Final[str] = _SELECTION_METHODS[6]  # "medoid"
     _SELECTION_METHODS_SET: Final[frozenset[SelectionMethod]] = frozenset(_SELECTION_METHODS)
 
     _DISTANCE_METRICS: Final[tuple[str, ...]] = (
@@ -531,12 +534,12 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         "power_mean",
         "weighted_sum",
     )
-    _METRIC_EUCLIDEAN: Final[str] = _DISTANCE_METRICS[0]
-    _METRIC_MINKOWSKI: Final[str] = _DISTANCE_METRICS[1]
-    _METRIC_HELLINGER: Final[str] = _DISTANCE_METRICS[8]
-    _METRIC_SHELLINGER: Final[str] = _DISTANCE_METRICS[9]
-    _METRIC_POWER_MEAN: Final[str] = _DISTANCE_METRICS[15]
-    _METRIC_WEIGHTED_SUM: Final[str] = _DISTANCE_METRICS[16]
+    _METRIC_EUCLIDEAN: Final[str] = _DISTANCE_METRICS[0]  # "euclidean"
+    _METRIC_MINKOWSKI: Final[str] = _DISTANCE_METRICS[1]  # "minkowski"
+    _METRIC_HELLINGER: Final[str] = _DISTANCE_METRICS[8]  # "hellinger"
+    _METRIC_SHELLINGER: Final[str] = _DISTANCE_METRICS[9]  # "shellinger"
+    _METRIC_POWER_MEAN: Final[str] = _DISTANCE_METRICS[15]  # "power_mean"
+    _METRIC_WEIGHTED_SUM: Final[str] = _DISTANCE_METRICS[16]  # "weighted_sum"
     _DISTANCE_METRICS_SET: Final[frozenset[str]] = frozenset(_DISTANCE_METRICS)
     # SciPy-compatible distance metrics: the first 8 entries of
     # ``_DISTANCE_METRICS`` route to ``scipy.spatial.distance.cdist``.
@@ -553,7 +556,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
     )
 
     _PROBABILITY_DISTANCE_METRICS: Final[tuple[str, ...]] = (
-        _DISTANCE_METRICS[7],
+        _DISTANCE_METRICS[7],  # "jensenshannon"
         _METRIC_HELLINGER,
         _METRIC_SHELLINGER,
     )
@@ -584,20 +587,20 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         "min",
         "max",
     )
-    _DENSITY_AGG_POWER_MEAN: Final[str] = _DENSITY_AGGREGATIONS[0]
-    _DENSITY_AGG_QUANTILE: Final[str] = _DENSITY_AGGREGATIONS[1]
-    _DENSITY_AGG_MIN: Final[str] = _DENSITY_AGGREGATIONS[2]
-    _DENSITY_AGG_MAX: Final[str] = _DENSITY_AGGREGATIONS[3]
+    _DENSITY_AGG_POWER_MEAN: Final[str] = _DENSITY_AGGREGATIONS[0]  # "power_mean"
+    _DENSITY_AGG_QUANTILE: Final[str] = _DENSITY_AGGREGATIONS[1]  # "quantile"
+    _DENSITY_AGG_MIN: Final[str] = _DENSITY_AGGREGATIONS[2]  # "min"
+    _DENSITY_AGG_MAX: Final[str] = _DENSITY_AGGREGATIONS[3]  # "max"
     _DENSITY_AGGREGATIONS_SET: Final[frozenset[DensityAggregation]] = frozenset(
         _DENSITY_AGGREGATIONS
     )
 
     _POWER_MEAN_MAP: Final[dict[str, float]] = {
-        _DISTANCE_METRICS[10]: -1.0,
-        _DISTANCE_METRICS[11]: 0.0,
-        _DISTANCE_METRICS[12]: 1.0,
-        _DISTANCE_METRICS[13]: 2.0,
-        _DISTANCE_METRICS[14]: 3.0,
+        _DISTANCE_METRICS[10]: -1.0,  # "harmonic_mean"
+        _DISTANCE_METRICS[11]: 0.0,  # "geometric_mean"
+        _DISTANCE_METRICS[12]: 1.0,  # "arithmetic_mean"
+        _DISTANCE_METRICS[13]: 2.0,  # "quadratic_mean"
+        _DISTANCE_METRICS[14]: 3.0,  # "cubic_mean"
     }
     _POWER_MEAN_METRICS_SET: Final[frozenset[str]] = frozenset(_POWER_MEAN_MAP)
 
@@ -657,8 +660,8 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         "train_test_split",
         "timeseries_split",
     )
-    DATA_SPLIT_METHOD_DEFAULT: Final[str] = _DATA_SPLIT_METHODS[0]
-    _DATA_SPLIT_TIMESERIES: Final[str] = _DATA_SPLIT_METHODS[1]
+    DATA_SPLIT_METHOD_DEFAULT: Final[str] = _DATA_SPLIT_METHODS[0]  # "train_test_split"
+    _DATA_SPLIT_TIMESERIES: Final[str] = _DATA_SPLIT_METHODS[1]  # "timeseries_split"
     TIMESERIES_N_SPLITS_DEFAULT: Final[int] = 5
     TIMESERIES_GAP_DEFAULT: Final[int] = 0
     TIMESERIES_MAX_TRAIN_SIZE_DEFAULT: Final[int | None] = None
@@ -831,7 +834,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
                 label_weights,
                 logger=logger,
                 context=context,
-                on_collapse=LABEL_WEIGHT_SUPPORT_POLICIES[0],
+                on_collapse=LABEL_WEIGHT_SUPPORT_POLICIES[0],  # "fallback"
             )
         except LabelWeightSupportError as exc:
             logger.warning(
@@ -903,7 +906,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
             # governs the contract -- ``raise`` raises, ``fallback``
             # warns. A direct return to base weights would bypass the
             # policy silently.
-            strategy = label_weighting_config.get("strategy", WEIGHT_STRATEGIES[0])
+            strategy = label_weighting_config.get("strategy", WEIGHT_STRATEGIES[0])  # "none"
             if strategy != WEIGHT_STRATEGIES[0]:  # "none"
                 return QuickAdapterRegressorV3._apply_support_policy(
                     base_weights,
@@ -1050,7 +1053,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
     ) -> float | None:
         if value is None:
             return None
-        if mode == _VALIDATION_MODES[2]:
+        if mode == _VALIDATION_MODES[2]:  # "none"
             return (
                 float(value)
                 if (np.isfinite(value) and (predicate is None or predicate(value)))
@@ -1059,14 +1062,14 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
 
         if not np.isfinite(value):
             msg = f"Invalid {ctx} value {value!r}: must be finite"
-            if mode == _VALIDATION_MODES[1]:
+            if mode == _VALIDATION_MODES[1]:  # "raise"
                 raise ValueError(msg)
             logger.warning(f"{msg}, using default")
             return None
 
         if predicate is not None and not predicate(value):
             msg = f"Invalid {ctx} value {value!r}: {constraint}"
-            if mode == _VALIDATION_MODES[1]:
+            if mode == _VALIDATION_MODES[1]:  # "raise"
                 raise ValueError(msg)
             logger.warning(f"{msg}, using default")
             return None
@@ -1075,7 +1078,10 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
 
     @staticmethod
     def _validate_minkowski_p(
-        p: float | None, *, ctx: str, mode: ValidationMode = _VALIDATION_MODES[1]
+        p: float | None,
+        *,
+        ctx: str,
+        mode: ValidationMode = _VALIDATION_MODES[1],  # "raise"
     ) -> float | None:
         return QuickAdapterRegressorV3._validate_scalar(
             p, ctx=ctx, mode=mode, predicate=lambda v: v > 0, constraint="must be > 0"
@@ -1086,7 +1092,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         distance_metric: str,
         weights: NDArray[np.floating] | None = None,
         p: float | None = None,
-        mode: ValidationMode = _VALIDATION_MODES[2],
+        mode: ValidationMode = _VALIDATION_MODES[2],  # "none"
         metric_ctx: str = "distance_metric",
         p_ctx: str = "p",
         *,
@@ -1128,7 +1134,10 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
 
     @staticmethod
     def _validate_quantile_q(
-        q: float | None, *, ctx: str, mode: ValidationMode = _VALIDATION_MODES[1]
+        q: float | None,
+        *,
+        ctx: str,
+        mode: ValidationMode = _VALIDATION_MODES[1],  # "raise"
     ) -> float | None:
         return QuickAdapterRegressorV3._validate_scalar(
             q,
@@ -1140,22 +1149,28 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
 
     @staticmethod
     def _validate_power_mean_p(
-        p: float | None, *, ctx: str, mode: ValidationMode = _VALIDATION_MODES[1]
+        p: float | None,
+        *,
+        ctx: str,
+        mode: ValidationMode = _VALIDATION_MODES[1],  # "raise"
     ) -> float | None:
         return QuickAdapterRegressorV3._validate_scalar(p, ctx=ctx, mode=mode)
 
     @staticmethod
     def _validate_metric_weights_support(
-        metric: str, *, ctx: str, mode: ValidationMode = _VALIDATION_MODES[0]
+        metric: str,
+        *,
+        ctx: str,
+        mode: ValidationMode = _VALIDATION_MODES[0],  # "warn"
     ) -> str | None:
         if metric not in QuickAdapterRegressorV3._UNSUPPORTED_WEIGHTS_METRICS_SET:
             return metric
 
-        if mode == _VALIDATION_MODES[2]:
+        if mode == _VALIDATION_MODES[2]:  # "none"
             return None
 
         msg = f"Invalid {ctx} value {metric!r}: does not support custom weights"
-        if mode == _VALIDATION_MODES[1]:
+        if mode == _VALIDATION_MODES[1]:  # "raise"
             raise ValueError(msg)
         logger.warning(f"{msg}, using uniform weights")
         return None
@@ -1166,7 +1181,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         n_objectives: int,
         *,
         ctx: str,
-        mode: ValidationMode = _VALIDATION_MODES[1],
+        mode: ValidationMode = _VALIDATION_MODES[1],  # "raise"
     ) -> NDArray[np.floating]:
         if weights is None:
             return np.full(n_objectives, 1.0 / n_objectives)
@@ -1196,9 +1211,9 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
                         return normalized
                     msg = f"Invalid {ctx} value: sum is zero"
 
-        if mode == _VALIDATION_MODES[1]:
+        if mode == _VALIDATION_MODES[1]:  # "raise"
             raise ValueError(msg)
-        if mode == _VALIDATION_MODES[0]:
+        if mode == _VALIDATION_MODES[0]:  # "warn"
             logger.warning(f"{msg}, using uniform weights")
         return np.full(n_objectives, 1.0 / n_objectives)
 
@@ -1209,17 +1224,17 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         valid_options: tuple[str, ...],
         *,
         ctx: str,
-        mode: ValidationMode = _VALIDATION_MODES[1],
+        mode: ValidationMode = _VALIDATION_MODES[1],  # "raise"
         default: str | None = None,
     ) -> str | None:
         if isinstance(value, str) and value in valid_set:
             return value
 
-        if mode == _VALIDATION_MODES[2]:
+        if mode == _VALIDATION_MODES[2]:  # "none"
             return default
 
         msg = enum_error_message(ctx, value, valid_options)
-        if mode == _VALIDATION_MODES[1]:
+        if mode == _VALIDATION_MODES[1]:  # "raise"
             raise ValueError(msg)
         logger.warning(f"{msg}, using {default!r}")
         return default
@@ -1231,7 +1246,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         ctx: str,
         default: str,
         aggregate_allowed: bool,
-        mode: ValidationMode = _VALIDATION_MODES[0],
+        mode: ValidationMode = _VALIDATION_MODES[0],  # "warn"
     ) -> str:
         if aggregate_allowed:
             valid_metrics = QuickAdapterRegressorV3._LABEL_SELECTION_DISTANCE_METRICS_SET
@@ -1262,7 +1277,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         label_p_order: float | None,
         *,
         ctx: str,
-        mode: ValidationMode = _VALIDATION_MODES[1],
+        mode: ValidationMode = _VALIDATION_MODES[1],  # "raise"
     ) -> float | None:
         p = (
             label_p_order
@@ -1279,7 +1294,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
             QuickAdapterRegressorV3._SELECTION_METHODS_SET,
             QuickAdapterRegressorV3._SELECTION_METHODS,
             ctx="label_method",
-            mode=_VALIDATION_MODES[1],
+            mode=_VALIDATION_MODES[1],  # "raise"
         )
 
         category = QuickAdapterRegressorV3._get_selection_category(label_method)
@@ -1296,7 +1311,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
             distance_metric = QuickAdapterRegressorV3._validate_label_selection_metric(
                 distance_metric,
                 ctx="label_distance_metric",
-                mode=_VALIDATION_MODES[0],
+                mode=_VALIDATION_MODES[0],  # "warn"
                 default=QuickAdapterRegressorV3.LABEL_DISTANCE_METRIC_DEFAULT,
                 aggregate_allowed=True,
             )
@@ -1309,7 +1324,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
             distance_metric = QuickAdapterRegressorV3._validate_label_selection_metric(
                 distance_metric,
                 ctx="label_cluster_metric",
-                mode=_VALIDATION_MODES[0],
+                mode=_VALIDATION_MODES[0],  # "warn"
                 default=QuickAdapterRegressorV3.LABEL_CLUSTER_METRIC_DEFAULT,
                 aggregate_allowed=False,
             )
@@ -1350,7 +1365,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
             distance_metric = QuickAdapterRegressorV3._validate_label_selection_metric(
                 distance_metric,
                 ctx="label_density_metric",
-                mode=_VALIDATION_MODES[0],
+                mode=_VALIDATION_MODES[0],  # "warn"
                 default=density_metric_default,
                 aggregate_allowed=False,
             )
@@ -1955,7 +1970,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
             QuickAdapterRegressorV3._SCALER_TYPES_SET,
             QuickAdapterRegressorV3._SCALER_TYPES,
             ctx="scaler",
-            mode=_VALIDATION_MODES[1],
+            mode=_VALIDATION_MODES[1],  # "raise"
         )
 
         feature_range = self.ft_params.get("range", QuickAdapterRegressorV3.RANGE_DEFAULT)
@@ -2280,9 +2295,10 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
                 "unfiltered_df.index (filter_features should preserve original "
                 "row labels)"
             )
-        if LABEL_COLUMNS[0] not in dk.label_list:
+        label_column = LABEL_COLUMNS[0]  # "&s-extrema"
+        if label_column not in dk.label_list:
             raise ValueError(
-                f"LABEL_COLUMNS[0]={LABEL_COLUMNS[0]!r} is not in "
+                f"LABEL_COLUMNS[0]={label_column!r} is not in "
                 f"dk.label_list={dk.label_list!r}: project label constant "
                 f"diverged from freqtrade's runtime label list"
             )
@@ -2300,9 +2316,11 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
 
         label_weighting = self.label_weighting
         label_weighting_config = get_label_column_config(
-            LABEL_COLUMNS[0], label_weighting["default"], label_weighting["columns"]
+            label_column,
+            label_weighting["default"],
+            label_weighting["columns"],
         )
-        weight_col = label_weight_column_name(LABEL_COLUMNS[0])
+        weight_col = label_weight_column_name(label_column)
         if weight_col in unfiltered_df.columns:
             label_weights = unfiltered_df.loc[features_filtered.index, weight_col].to_numpy(
                 dtype=float
@@ -2336,8 +2354,8 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
             model_class = LGBMRegressor
         elif self.regressor == _REGRESSOR_SPECS.catboost.name:
             if (
-                self.model_training_parameters.get("task_type", _CATBOOST_TASK_TYPES[0])
-                == _CATBOOST_TASK_TYPES[1]
+                self.model_training_parameters.get("task_type", _CATBOOST_TASK_TYPES[0])  # "CPU"
+                == _CATBOOST_TASK_TYPES[1]  # "GPU"
             ):
                 return None
             from catboost import CatBoostRegressor
@@ -3819,7 +3837,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
         *,
         weights: NDArray[np.floating] | None = None,
         p: float | None = None,
-        mode: ValidationMode = _VALIDATION_MODES[2],
+        mode: ValidationMode = _VALIDATION_MODES[2],  # "none"
         p_ctx: str = "p",
     ) -> NDArray[np.floating]:
         if distance_metric in QuickAdapterRegressorV3._POWER_MEAN_METRICS_SET:
@@ -3891,7 +3909,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
                 distance_metric,
                 weights=weights,
                 p=p,
-                mode=_VALIDATION_MODES[0],
+                mode=_VALIDATION_MODES[0],  # "warn"
                 p_ctx="label_distance_p",
             )
             return np.abs(distances) if apply_abs else distances
@@ -4503,7 +4521,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
                     label_weights_array,
                     original_n_objectives,
                     ctx="label_weights",
-                    mode=_VALIDATION_MODES[1],
+                    mode=_VALIDATION_MODES[1],  # "raise"
                 )
                 sliced_weights = label_weights_array[objective_indices]
                 if np.all(sliced_weights == 0.0):
@@ -4521,7 +4539,7 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
             label_weights,
             n_objectives,
             ctx="label_weights",
-            mode=_VALIDATION_MODES[1],
+            mode=_VALIDATION_MODES[1],  # "raise"
         )
         if category == QuickAdapterRegressorV3._CATEGORY_CLUSTER:
             positive_weight = weights > 0.0
@@ -4543,14 +4561,14 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
             distance_metric,
             label_p_order,
             ctx=f"label_p_order for {method}",
-            mode=_VALIDATION_MODES[2],
+            mode=_VALIDATION_MODES[2],  # "none"
         )
         distance_kwargs = (
             QuickAdapterRegressorV3._prepare_distance_kwargs(
                 distance_metric,
                 weights=weights,
                 p=p,
-                mode=_VALIDATION_MODES[0],
+                mode=_VALIDATION_MODES[0],  # "warn"
                 metric_ctx=f"label_{category}_metric",
                 reference_matrix=normalized_matrix,
             )
@@ -4770,14 +4788,14 @@ class QuickAdapterRegressorV3(BaseRegressionModel):
             label_config = self._resolve_label_method_config(
                 self.ft_params.get("label_method", QuickAdapterRegressorV3.LABEL_METHOD_DEFAULT)
             )
-            metric_log_msg = f" ({format_dict(label_config, style=_FORMAT_STYLES[1])})"
+            metric_log_msg = f" ({format_dict(label_config, style=_FORMAT_STYLE_PARAMS)})"
         logger.info(
             f"[{pair}] Optuna {namespace} {objective_type} objective hyperopt completed"
             f"{metric_log_msg} ({time_spent:.2f} secs)"
         )
         if study_best_results:
             logger.info(
-                f"[{pair}] Optuna {namespace} {objective_type} objective hyperopt best params: {format_dict(study_best_results, style=_FORMAT_STYLES[0])}"
+                f"[{pair}] Optuna {namespace} {objective_type} objective hyperopt best params: {format_dict(study_best_results, style=_FORMAT_STYLE_DICT)}"
             )
         if not self.optuna_validate_params(pair, namespace, study):
             logger.warning(
index 75ec461233aa02685fbdc6ea5ddf0e1268330e32..2cc0404bdfdf5fe6413e4f91256de70456ff38db 100644 (file)
@@ -513,7 +513,10 @@ class LabelTransformer(BaseTransform):
             state.minmax_scaler = MinMaxScaler(feature_range=state.config["minmax_range"])
             state.minmax_scaler.fit(values.reshape(-1, 1))
             return
-        if method in (NORMALIZATION_TYPES[2], NORMALIZATION_TYPES[3]):  # sigmoid, none
+        if method in (
+            NORMALIZATION_TYPES[2],
+            NORMALIZATION_TYPES[3],
+        ):  # sigmoid, none
             return
 
         raise ValueError(enum_error_message("normalization", method, NORMALIZATION_TYPES))
index cfc3dd00efb010a235a8aad7bf218e29d680f7ff..f5ee4b0581942d0a6e90e491feb34a06692f38e0 100644 (file)
@@ -38,7 +38,8 @@ from pandas import DataFrame, Series, isna, to_numeric
 from technical.pivots_points import pivots_points
 from Utils import (
     _CACHE_MAXSIZE_LARGE,
-    _FORMAT_STYLES,
+    _FORMAT_STYLE_DICT,
+    _FORMAT_STYLE_PARAMS,
     _OPTUNA_NAMESPACES,
     EXTREMA_COLUMN,
     EXTREMA_DIRECTION_COLUMN,
@@ -188,29 +189,29 @@ class QuickAdapterV3(IStrategy):
     INTERFACE_VERSION = 3
 
     _TRADE_DIRECTIONS: Final[tuple[TradeDirection, ...]] = ("long", "short")
-    _TRADE_LONG: Final[str] = _TRADE_DIRECTIONS[0]
-    _TRADE_SHORT: Final[str] = _TRADE_DIRECTIONS[1]
+    _TRADE_LONG: Final[str] = _TRADE_DIRECTIONS[0]  # "long"
+    _TRADE_SHORT: Final[str] = _TRADE_DIRECTIONS[1]  # "short"
     _TRADE_DIRECTIONS_SET: Final[frozenset[TradeDirection]] = frozenset(_TRADE_DIRECTIONS)
     _INTERPOLATION_DIRECTIONS: Final[tuple[InterpolationDirection, ...]] = (
         "direct",
         "inverse",
     )
-    _INTERPOLATION_DIRECT: Final[str] = _INTERPOLATION_DIRECTIONS[0]
-    _INTERPOLATION_INVERSE: Final[str] = _INTERPOLATION_DIRECTIONS[1]
+    _INTERPOLATION_DIRECT: Final[str] = _INTERPOLATION_DIRECTIONS[0]  # "direct"
+    _INTERPOLATION_INVERSE: Final[str] = _INTERPOLATION_DIRECTIONS[1]  # "inverse"
     _ORDER_TYPES: Final[tuple[OrderType, ...]] = ("entry", "exit")
-    _ORDER_ENTRY: Final[str] = _ORDER_TYPES[0]
-    _ORDER_EXIT: Final[str] = _ORDER_TYPES[1]
+    _ORDER_ENTRY: Final[str] = _ORDER_TYPES[0]  # "entry"
+    _ORDER_EXIT: Final[str] = _ORDER_TYPES[1]  # "exit"
     _ORDER_TYPES_SET: Final[frozenset[OrderType]] = frozenset(_ORDER_TYPES)
     _TRADING_MODES: Final[tuple[TradingMode, ...]] = ("spot", "margin", "futures")
-    _TRADING_MODE_SPOT: Final[str] = _TRADING_MODES[0]
-    _TRADING_MODE_MARGIN: Final[str] = _TRADING_MODES[1]
-    _TRADING_MODE_FUTURES: Final[str] = _TRADING_MODES[2]
-    _SMOOTHING_SMM: Final[str] = SMOOTHING_METHODS[5]
-    _SMOOTHING_SAVGOL: Final[str] = SMOOTHING_METHODS[7]
-    _FILL_EPSILON: Final[str] = FILL_METHODS[1]
-    _FILL_GAUSSIAN: Final[str] = FILL_METHODS[2]
-    _FILL_EPSILON_GAUSSIAN: Final[str] = FILL_METHODS[3]
-    _WEIGHT_NONE: Final[str] = WEIGHT_STRATEGIES[0]
+    _TRADING_MODE_SPOT: Final[str] = _TRADING_MODES[0]  # "spot"
+    _TRADING_MODE_MARGIN: Final[str] = _TRADING_MODES[1]  # "margin"
+    _TRADING_MODE_FUTURES: Final[str] = _TRADING_MODES[2]  # "futures"
+    _SMOOTHING_SMM: Final[str] = SMOOTHING_METHODS[5]  # "smm"
+    _SMOOTHING_SAVGOL: Final[str] = SMOOTHING_METHODS[7]  # "savgol"
+    _FILL_EPSILON: Final[str] = FILL_METHODS[1]  # "epsilon"
+    _FILL_GAUSSIAN: Final[str] = FILL_METHODS[2]  # "gaussian"
+    _FILL_EPSILON_GAUSSIAN: Final[str] = FILL_METHODS[3]  # "epsilon_gaussian"
+    _WEIGHT_NONE: Final[str] = WEIGHT_STRATEGIES[0]  # "none"
 
     _CUSTOM_STOPLOSS_NATR_MULTIPLIER_FRACTION: Final[float] = 0.7860
 
@@ -469,8 +470,8 @@ class QuickAdapterV3(IStrategy):
                 )
                 if (
                     col_smoothing_config["method"] in SMOOTHING_METHOD_MODES
-                    and col_smoothing_config["mode"] == SMOOTHING_MODES[3]
-                ):  # "wrap"
+                    and col_smoothing_config["mode"] == SMOOTHING_MODES[3]  # "wrap"
+                ):
                     raise ValueError(
                         "label_smoothing.mode='wrap' is incompatible with "
                         "feature_parameters.causal_mode=true"
@@ -525,7 +526,7 @@ class QuickAdapterV3(IStrategy):
             logger.info("  Weighting:")
             logger.info(f"    strategy: {col_weighting['strategy']}")
             logger.info(
-                f"    metric_coefficients: {format_dict(col_weighting['metric_coefficients'], style=_FORMAT_STYLES[0])}"
+                f"    metric_coefficients: {format_dict(col_weighting['metric_coefficients'], style=_FORMAT_STYLE_DICT)}"
             )
             logger.info(f"    aggregation: {col_weighting['aggregation']}")
             if col_weighting["aggregation"] == COMBINED_AGGREGATIONS[5]:  # "softmax"
@@ -642,7 +643,7 @@ class QuickAdapterV3(IStrategy):
                 method = protection.get("method", "Unknown")
                 protection_params = {k: v for k, v in protection.items() if k != "method"}
                 logger.info(
-                    f"  {method}: {format_dict(protection_params, style=_FORMAT_STYLES[0])}"
+                    f"  {method}: {format_dict(protection_params, style=_FORMAT_STYLE_DICT)}"
                 )
         else:
             logger.info("  No protections enabled")
@@ -740,8 +741,8 @@ class QuickAdapterV3(IStrategy):
         )
         dataframe["%-ewo"] = ewo(
             dataframe=dataframe,
-            pricemode=PRICE_MODES[4],
-            mamode=MA_MODES[1],
+            pricemode=PRICE_MODES[4],  # "close"
+            mamode=MA_MODES[1],  # "ema"
             zero_lag=True,
             normalize=True,
             logger=logger,
@@ -781,7 +782,9 @@ class QuickAdapterV3(IStrategy):
         )
         dataframe["%-ibs"] = (closes - lows) / non_zero_diff(highs, lows)
         dataframe["jaw"], dataframe["teeth"], dataframe["lips"] = alligator(
-            dataframe, pricemode=PRICE_MODES[1], zero_lag=True
+            dataframe,
+            pricemode=PRICE_MODES[1],  # "median"
+            zero_lag=True,
         )
         dataframe["%-dist_to_jaw"] = get_distance(closes, dataframe["jaw"])
         dataframe["%-dist_to_teeth"] = get_distance(closes, dataframe["teeth"])
@@ -973,11 +976,11 @@ class QuickAdapterV3(IStrategy):
 
             if len(label_data.indices) == 0:
                 logger.warning(
-                    f"[{pair}] No {label_col!r} labels | series_duration: {QuickAdapterV3._td_format(series_duration)} | params: {format_dict(label_params, style=_FORMAT_STYLES[1])}"
+                    f"[{pair}] No {label_col!r} labels | series_duration: {QuickAdapterV3._td_format(series_duration)} | params: {format_dict(label_params, style=_FORMAT_STYLE_PARAMS)}"
                 )
             else:
                 logger.info(
-                    f"[{pair}] {len(label_data.indices)} {label_col!r} labels | series_duration: {QuickAdapterV3._td_format(series_duration)} | params: {format_dict(label_params, style=_FORMAT_STYLES[1])}"
+                    f"[{pair}] {len(label_data.indices)} {label_col!r} labels | series_duration: {QuickAdapterV3._td_format(series_duration)} | params: {format_dict(label_params, style=_FORMAT_STYLE_PARAMS)}"
                 )
 
             col_weighting_config = get_label_column_config(
@@ -1276,7 +1279,7 @@ class QuickAdapterV3(IStrategy):
         if label_natr is None or label_natr.empty:
             return None
         if trade_duration_candles >= 2:
-            kama = get_ma_fn(MA_MODES[6])
+            kama = get_ma_fn(MA_MODES[6])  # "kama"
             try:
                 trade_kama_natr_values = np.asarray(
                     kama(label_natr, timeperiod=trade_duration_candles), dtype=float
@@ -1967,7 +1970,7 @@ class QuickAdapterV3(IStrategy):
         min_natr_multiplier_fraction: float,
         max_natr_multiplier_fraction: float,
         candle_idx: int = -1,
-        interpolation_direction: InterpolationDirection = _INTERPOLATION_DIRECTIONS[0],
+        interpolation_direction: InterpolationDirection = _INTERPOLATION_DIRECTIONS[0],  # "direct"
         quantile_exponent: float = 1.5,
     ) -> float:
         df_signature = QuickAdapterV3._df_signature(df)
index 4a309f94de8b0641357b01e6b9df99e375f69b20..1895ae7e1c7af854e79ad1e7bcc7a974ec6b4126 100644 (file)
@@ -847,12 +847,14 @@ def _generate_extrema_label(
         series.loc[result.indices] = result.directions
 
     metrics: dict[str, list[float]] = {
-        COMBINED_METRICS[0]: result.amplitudes,
-        COMBINED_METRICS[1]: result.amplitude_threshold_ratios,
-        COMBINED_METRICS[2]: result.volume_rates,
-        COMBINED_METRICS[3]: result.speeds,
-        COMBINED_METRICS[4]: result.efficiency_ratios,
-        COMBINED_METRICS[5]: result.volume_weighted_efficiency_ratios,
+        COMBINED_METRICS[0]: result.amplitudes,  # "amplitude"
+        COMBINED_METRICS[1]: result.amplitude_threshold_ratios,  # "amplitude_threshold_ratio"
+        COMBINED_METRICS[2]: result.volume_rates,  # "volume_rate"
+        COMBINED_METRICS[3]: result.speeds,  # "speed"
+        COMBINED_METRICS[4]: result.efficiency_ratios,  # "efficiency_ratio"
+        COMBINED_METRICS[
+            5
+        ]: result.volume_weighted_efficiency_ratios,  # "volume_weighted_efficiency_ratio"
     }
 
     known_at_lookahead = pd.Series(
@@ -932,7 +934,7 @@ def get_smoothing_kernel_half_width(
     (``smooth()`` top-level no-op), and for the filtfilt/savgol routes
     when their downstream short-series guards make smoothing a no-op.
     """
-    method = config.get("method", SMOOTHING_METHODS[0])
+    method = config.get("method", SMOOTHING_METHODS[0])  # "none"
     if method == SMOOTHING_METHODS[0]:  # "none"
         return 0
     raw_window = max(
@@ -947,7 +949,9 @@ def get_smoothing_kernel_half_width(
         return int(4.0 * sigma + 0.5)
     if method == SMOOTHING_METHODS[7]:  # "savgol"
         polyorder = max(int(config.get("polyorder", DEFAULTS_LABEL_SMOOTHING["polyorder"])), 0)
-        effective_window, _, _ = get_savgol_params(raw_window, polyorder, SMOOTHING_MODES[0])
+        effective_window, _, _ = get_savgol_params(
+            raw_window, polyorder, SMOOTHING_MODES[0]
+        )  # "mirror"
     elif method == SMOOTHING_METHODS[3]:  # "kaiser_bessel_derived"
         effective_window = get_even_window(raw_window)
     else:
@@ -956,7 +960,7 @@ def get_smoothing_kernel_half_width(
         if series_length <= _filtfilt_default_padlen(effective_window, 1):
             return 0
         return effective_window - 1
-    if method == SMOOTHING_METHODS[7] and series_length < effective_window:
+    if method == SMOOTHING_METHODS[7] and series_length < effective_window:  # "savgol"
         return 0
     return effective_window // 2
 
@@ -1010,7 +1014,9 @@ def compose_label_lookahead(
         center=True,
         min_periods=1,
     ).max()
-    if method == SMOOTHING_METHODS[7] and mode == SMOOTHING_MODES[4]:
+    if (
+        method == SMOOTHING_METHODS[7] and mode == SMOOTHING_MODES[4]  # "interp"
+    ):  # "savgol"; SMOOTHING_MODES[4]='interp'
         smoothed_known_at_positions.iloc[:kernel_half_width] = known_at_positions.iloc[
             : 2 * kernel_half_width + 1
         ].max()
@@ -1843,7 +1849,7 @@ def compose_sample_weights(
     *,
     logger: Logger,
     context: str,
-    on_collapse: Literal["raise", "fallback"] = LABEL_WEIGHT_SUPPORT_POLICIES[1],
+    on_collapse: Literal["raise", "fallback"] = LABEL_WEIGHT_SUPPORT_POLICIES[1],  # "raise"
 ) -> NDArray[np.floating]:
     """Combine base sample weights with the label importance weights.
 
@@ -2301,7 +2307,7 @@ def _gaussian_fill_weights(
     pivot_weights: NDArray[np.floating],
     sigma_candles: float,
     *,
-    bandwidth: str = FILL_BANDWIDTHS[0],
+    bandwidth: str = FILL_BANDWIDTHS[0],  # "fixed"
     bandwidth_neighbors: int = 1,
     bandwidth_alpha: float = 1.0,
     sigma_min_candles: float = 0.5,
@@ -3336,7 +3342,7 @@ def compute_label_weight_known_at_lookahead(
             < float(label_weighting["fill_sigma_candles"])
         )
         uniform_gaussian = (
-            label_weighting["strategy"] == WEIGHT_STRATEGIES[1]
+            label_weighting["strategy"] == WEIGHT_STRATEGIES[1]  # "uniform"
             and label_weighting["fill_method"] == FILL_METHODS[2]  # "gaussian"
         )
         band_weight_availability = (
@@ -3599,22 +3605,24 @@ def _format_collection(
 
 
 _FORMAT_STYLES: Final[tuple[Literal["dict", "params"], ...]] = ("dict", "params")
+_FORMAT_STYLE_DICT: Final[Literal["dict"]] = _FORMAT_STYLES[0]  # "dict"
+_FORMAT_STYLE_PARAMS: Final[Literal["params"]] = _FORMAT_STYLES[1]  # "params"
 
 
 def format_dict(
     d: dict[str, Any],
-    style: Literal["dict", "params"] = _FORMAT_STYLES[0],
+    style: Literal["dict", "params"] = _FORMAT_STYLE_DICT,
     significant_digits: int = 5,
 ) -> str:
     if not d:
-        return "{}" if style == _FORMAT_STYLES[0] else ""
+        return "{}" if style == _FORMAT_STYLE_DICT else ""
 
-    ctx = _FormatContext(quote_strings=(style == _FORMAT_STYLES[0]), sig_digits=significant_digits)
-    sep = ": " if style == _FORMAT_STYLES[0] else "="
+    ctx = _FormatContext(quote_strings=(style == _FORMAT_STYLE_DICT), sig_digits=significant_digits)
+    sep = ": " if style == _FORMAT_STYLE_DICT else "="
     items = [f"{k}{sep}{_format_value(v, ctx, 0)}" for k, v in d.items()]
     joined = ", ".join(items)
 
-    return f"{{{joined}}}" if style == _FORMAT_STYLES[0] else joined
+    return f"{{{joined}}}" if style == _FORMAT_STYLE_DICT else joined
 
 
 @lru_cache(maxsize=_CACHE_MAXSIZE_LARGE)
@@ -3748,16 +3756,16 @@ def get_ma_fn(
         str,
         Callable[[pd.Series | NDArray[np.floating], int], pd.Series | NDArray[np.floating]],
     ] = {
-        MA_MODES[0]: ta.SMA,
-        MA_MODES[1]: ta.EMA,
-        MA_MODES[2]: ta.WMA,
-        MA_MODES[3]: ta.DEMA,
-        MA_MODES[4]: ta.TEMA,
-        MA_MODES[5]: ta.TRIMA,
-        MA_MODES[6]: ta.KAMA,
-        MA_MODES[7]: ta.T3,
+        MA_MODES[0]: ta.SMA,  # "sma"
+        MA_MODES[1]: ta.EMA,  # "ema"
+        MA_MODES[2]: ta.WMA,  # "wma"
+        MA_MODES[3]: ta.DEMA,  # "dema"
+        MA_MODES[4]: ta.TEMA,  # "tema"
+        MA_MODES[5]: ta.TRIMA,  # "trima"
+        MA_MODES[6]: ta.KAMA,  # "kama"
+        MA_MODES[7]: ta.T3,  # "t3"
     }
-    return mamodes.get(mamode, mamodes[MA_MODES[0]])
+    return mamodes.get(mamode, mamodes[MA_MODES[0]])  # "sma"
 
 
 @lru_cache(maxsize=_CACHE_MAXSIZE_SMALL)
@@ -3874,21 +3882,21 @@ def smma(series: pd.Series, period: int, zero_lag=False, offset=0) -> pd.Series:
 @lru_cache(maxsize=_CACHE_MAXSIZE_SMALL)
 def get_price_fn(pricemode: str) -> Callable[[pd.DataFrame], pd.Series]:
     pricemodes = {
-        PRICE_MODES[0]: ta.AVGPRICE,
-        PRICE_MODES[1]: ta.MEDPRICE,
-        PRICE_MODES[2]: ta.TYPPRICE,
-        PRICE_MODES[3]: ta.WCLPRICE,
-        PRICE_MODES[4]: lambda df: df.get("close"),
+        PRICE_MODES[0]: ta.AVGPRICE,  # "average"
+        PRICE_MODES[1]: ta.MEDPRICE,  # "median"
+        PRICE_MODES[2]: ta.TYPPRICE,  # "typical"
+        PRICE_MODES[3]: ta.WCLPRICE,  # "weighted-close"
+        PRICE_MODES[4]: lambda df: df.get("close"),  # "close"
     }
-    return pricemodes.get(pricemode, pricemodes[PRICE_MODES[4]])
+    return pricemodes.get(pricemode, pricemodes[PRICE_MODES[4]])  # "close"
 
 
 def ewo(
     dataframe: pd.DataFrame,
     ma1_length: int = 5,
     ma2_length: int = 34,
-    pricemode: str = PRICE_MODES[4],
-    mamode: str = MA_MODES[0],
+    pricemode: str = PRICE_MODES[4],  # "close"
+    mamode: str = MA_MODES[0],  # "sma"
     zero_lag: bool = False,
     normalize: bool = False,
     *,
@@ -3900,7 +3908,7 @@ def ewo(
     prices = get_price_fn(pricemode)(dataframe)
 
     if zero_lag:
-        if mamode == MA_MODES[1]:
+        if mamode == MA_MODES[1]:  # "ema"
 
             def ma_fn(series, timeperiod):
                 return zlema(series, period=timeperiod)
@@ -3933,7 +3941,7 @@ def alligator(
     jaw_shift: int = 8,
     teeth_shift: int = 5,
     lips_shift: int = 3,
-    pricemode: str = PRICE_MODES[1],
+    pricemode: str = PRICE_MODES[1],  # "median"
     zero_lag: bool = False,
 ) -> tuple[pd.Series, pd.Series, pd.Series]:
     """
@@ -4719,11 +4727,11 @@ def get_ngboost_dist(dist_name: str) -> type:
     from ngboost.distns import Exponential, Laplace, LogNormal, Normal, T
 
     dist_map = {
-        _NGBOOST_DISTRIBUTIONS[0]: Normal,
-        _NGBOOST_DISTRIBUTIONS[1]: LogNormal,
-        _NGBOOST_DISTRIBUTIONS[2]: Exponential,
-        _NGBOOST_DISTRIBUTIONS[3]: Laplace,
-        _NGBOOST_DISTRIBUTIONS[4]: T,
+        _NGBOOST_DISTRIBUTIONS[0]: Normal,  # "normal"
+        _NGBOOST_DISTRIBUTIONS[1]: LogNormal,  # "lognormal"
+        _NGBOOST_DISTRIBUTIONS[2]: Exponential,  # "exponential"
+        _NGBOOST_DISTRIBUTIONS[3]: Laplace,  # "laplace"
+        _NGBOOST_DISTRIBUTIONS[4]: T,  # "t"
     }
 
     if dist_name not in dist_map:
@@ -4947,8 +4955,8 @@ def fit_regressor(
 
         early_stopping_rounds = _pop_early_stopping_rounds(model_training_parameters, has_eval_set)
 
-        dist = model_training_parameters.pop("dist", _NGBOOST_DISTRIBUTIONS[0])
-        if dist == _NGBOOST_DISTRIBUTIONS[1]:
+        dist = model_training_parameters.pop("dist", _NGBOOST_DISTRIBUTIONS[0])  # "normal"
+        if dist == _NGBOOST_DISTRIBUTIONS[1]:  # "lognormal"
             label_sets = [y] + ([labels for _, labels in eval_set] if eval_set else [])
             if any(
                 not np.all(np.isfinite(values) & (values > 0))
@@ -5007,9 +5015,9 @@ def fit_regressor(
             else:
                 model_training_parameters["train_dir"] = str(model_path / "catboost_info")
 
-        task_type = model_training_parameters.get("task_type", _CATBOOST_TASK_TYPES[0])
+        task_type = model_training_parameters.get("task_type", _CATBOOST_TASK_TYPES[0])  # "CPU"
         loss_function = model_training_parameters.get("loss_function", _CATBOOST_DEFAULT_LOSS)
-        if task_type == _CATBOOST_TASK_TYPES[1]:
+        if task_type == _CATBOOST_TASK_TYPES[1]:  # "GPU"
             model_training_parameters.pop("gpu_vram_gb", None)
             model_training_parameters.pop("n_jobs", None)
             model_training_parameters.setdefault("max_ctr_complexity", 4)
@@ -5029,7 +5037,7 @@ def fit_regressor(
         _apply_verbosity_alias(model_training_parameters)
 
         pruning_callback = None
-        if trial is not None and has_eval_set and task_type != _CATBOOST_TASK_TYPES[1]:
+        if trial is not None and has_eval_set and task_type != _CATBOOST_TASK_TYPES[1]:  # "GPU"
             pruning_callback = optuna.integration.CatBoostPruningCallback(
                 trial, _CATBOOST_DEFAULT_LOSS
             )
@@ -5557,7 +5565,7 @@ def resolve_optuna_model_parameters(regressor: Regressor, params: dict[str, Any]
     resolved = params.copy()
     if (
         regressor == _REGRESSOR_SPECS.xgboost.name
-        and resolved.get("grow_policy") == _XGBOOST_GROW_POLICIES[1]
+        and resolved.get("grow_policy") == _XGBOOST_GROW_POLICIES[1]  # "lossguide"
     ):
         resolved["max_depth"] = 0
     elif regressor == _REGRESSOR_SPECS.histgradientboostingregressor.name and resolved.pop(
@@ -5673,7 +5681,7 @@ def get_optuna_study_model_parameters(
                         trial, "max_leaves", ranges["max_leaves"], min_val=2, log=True
                     ),
                 }
-                if grow_policy == _XGBOOST_GROW_POLICIES[1]
+                if grow_policy == _XGBOOST_GROW_POLICIES[1]  # "lossguide"
                 else {
                     "max_depth": _optuna_suggest_int_from_range(
                         trial, "max_depth", ranges["max_depth"], min_val=1
@@ -5720,7 +5728,7 @@ def get_optuna_study_model_parameters(
             ),
         }
 
-        if booster == _XGBOOST_BOOSTERS[1]:
+        if booster == _XGBOOST_BOOSTERS[1]:  # "dart"
             params["sample_type"] = trial.suggest_categorical(
                 "sample_type", ["uniform", "weighted"]
             )
@@ -5827,7 +5835,7 @@ def get_optuna_study_model_parameters(
             ),
         }
 
-        if boosting_type == _LIGHTGBM_BOOSTING_TYPES[1]:
+        if boosting_type == _LIGHTGBM_BOOSTING_TYPES[1]:  # "dart"
             params["xgboost_dart_mode"] = trial.suggest_categorical(
                 "xgboost_dart_mode", [False, True]
             )
@@ -6009,10 +6017,10 @@ def get_optuna_study_model_parameters(
 
     elif regressor == _REGRESSOR_SPECS.catboost.name:
         # Parameter order: boosting -> tree structure -> regularization -> sampling
-        task_type = model_training_parameters.get("task_type", _CATBOOST_TASK_TYPES[0])
+        task_type = model_training_parameters.get("task_type", _CATBOOST_TASK_TYPES[0])  # "CPU"
         loss_function = model_training_parameters.get("loss_function", _CATBOOST_DEFAULT_LOSS)
 
-        if task_type == _CATBOOST_TASK_TYPES[1]:
+        if task_type == _CATBOOST_TASK_TYPES[1]:  # "GPU"
             gpu_vram_gb = model_training_parameters.get("gpu_vram_gb", _CATBOOST_GPU_VRAM_DEFAULT)
             matched_vram_gb = max(
                 (v for v in _CATBOOST_GPU_VRAM_PARAM_RANGES if v <= gpu_vram_gb),
@@ -6078,8 +6086,8 @@ def get_optuna_study_model_parameters(
         bootstrap_type = trial.suggest_categorical("bootstrap_type", bootstrap_options)
         grow_policy = trial.suggest_categorical("grow_policy", _CATBOOST_GROW_POLICIES)
         if (
-            boosting_type == _CATBOOST_BOOSTING_TYPES[1]
-            and grow_policy != _CATBOOST_GROW_POLICIES[0]
+            boosting_type == _CATBOOST_BOOSTING_TYPES[1]  # "Ordered"
+            and grow_policy != _CATBOOST_GROW_POLICIES[0]  # "SymmetricTree"
         ):
             raise optuna.TrialPruned("Ordered boosting is not supported for nonsymmetric trees")
 
@@ -6127,7 +6135,7 @@ def get_optuna_study_model_parameters(
         }
 
         if (
-            task_type == _CATBOOST_TASK_TYPES[0]
+            task_type == _CATBOOST_TASK_TYPES[0]  # "CPU"
             or loss_function in _CATBOOST_GPU_RSM_LOSS_FUNCTIONS
         ):
             params["rsm"] = trial.suggest_float(
@@ -6136,7 +6144,7 @@ def get_optuna_study_model_parameters(
                 ranges["rsm"][1],
             )
 
-        if bootstrap_type == _CATBOOST_BOOTSTRAP_TYPES[0]:
+        if bootstrap_type == _CATBOOST_BOOTSTRAP_TYPES[0]:  # "Bayesian"
             params["bagging_temperature"] = trial.suggest_float(
                 "bagging_temperature",
                 ranges["bagging_temperature"][0],
@@ -6150,7 +6158,7 @@ def get_optuna_study_model_parameters(
                 ranges["subsample"][1],
             )
 
-        if task_type == _CATBOOST_TASK_TYPES[1]:
+        if task_type == _CATBOOST_TASK_TYPES[1]:  # "GPU"
             params["border_count"] = _optuna_suggest_int_from_range(
                 trial, "border_count", ranges["border_count"], min_val=1
             )