params = self._optuna_label_params.get(pair)
else:
raise ValueError(
- f"Invalid namespace '{namespace}'. "
+ f"Invalid namespace {namespace!r}. "
f"Supported: {', '.join(QuickAdapterRegressorV3._OPTUNA_NAMESPACES)}"
)
return params
self._optuna_label_params[pair] = params
else:
raise ValueError(
- f"Invalid namespace '{namespace}'. "
+ f"Invalid namespace {namespace!r}. "
f"Supported: {', '.join(QuickAdapterRegressorV3._OPTUNA_NAMESPACES)}"
)
value = self._optuna_train_value.get(pair)
else:
raise ValueError(
- f"Invalid namespace '{namespace}'. "
+ f"Invalid namespace {namespace!r}. "
f"Supported: {', '.join(QuickAdapterRegressorV3._OPTUNA_NAMESPACES[:2])}" # Only hp and train
)
return value
self._optuna_train_value[pair] = value
else:
raise ValueError(
- f"Invalid namespace '{namespace}'. "
+ f"Invalid namespace {namespace!r}. "
f"Supported: {', '.join(QuickAdapterRegressorV3._OPTUNA_NAMESPACES[:2])}" # Only hp and train
)
values = self._optuna_label_values.get(pair)
else:
raise ValueError(
- f"Invalid namespace '{namespace}'. "
+ f"Invalid namespace {namespace!r}. "
f"Supported: {QuickAdapterRegressorV3._OPTUNA_NAMESPACES[2]}" # Only label
)
return values
self._optuna_label_values[pair] = values
else:
raise ValueError(
- f"Invalid namespace '{namespace}'. "
+ f"Invalid namespace {namespace!r}. "
f"Supported: {QuickAdapterRegressorV3._OPTUNA_NAMESPACES[2]}" # Only label
)
QuickAdapterRegressorV3._OPTUNA_NAMESPACES[2]
}: # Only "label"
raise ValueError(
- f"Invalid namespace '{namespace}'. "
+ f"Invalid namespace {namespace!r}. "
f"Supported: {QuickAdapterRegressorV3._OPTUNA_NAMESPACES[2]}" # Only label
)
if not callable(callback):
pred_minima = pred_extrema[pred_extrema < -eps]
else:
raise ValueError(
- f"Invalid extrema_selection '{extrema_selection}'. "
+ f"Invalid extrema_selection {extrema_selection!r}. "
f"Supported: {', '.join(QuickAdapterRegressorV3._EXTREMA_SELECTION_METHODS)}"
)
threshold_func = getattr(skimage.filters, f"threshold_{method}")
except AttributeError:
raise ValueError(
- f"Invalid skimage threshold method '{method}'. "
+ f"Invalid skimage threshold method {method!r}. "
f"Supported: {', '.join(QuickAdapterRegressorV3._SKIMAGE_THRESHOLD_METHODS)}"
)
return threshold_func(values)
except Exception as e:
logger.warning(
- f"Failed to apply skimage threshold function {threshold_func.__name__} on series {series.name}: {e!r}, falling back to median",
+ f"Threshold function {threshold_func.__name__} failed on series {series.name}: {e!r}, falling back to median",
exc_info=True,
)
return np.nanmedian(values)
raise ValueError("Invalid weights: must be finite and non-negative")
if metric in QuickAdapterRegressorV3._unsupported_cluster_metrics_set():
raise ValueError(
- f"Invalid weights: not supported for metric '{metric}'"
+ f"Invalid weights: not supported for metric {metric!r}"
)
matrix = np.asarray(matrix, dtype=np.float64)
in QuickAdapterRegressorV3._unsupported_cluster_metrics_set()
):
raise ValueError(
- f"Invalid label_medoid_metric '{label_medoid_metric}'. "
+ f"Invalid label_medoid_metric {label_medoid_metric!r}. "
f"Unsupported: {', '.join(QuickAdapterRegressorV3._UNSUPPORTED_CLUSTER_METRICS)}"
)
p = None
in QuickAdapterRegressorV3._unsupported_cluster_metrics_set()
):
raise ValueError(
- f"Invalid label_kmeans_metric '{label_kmeans_metric}'. "
+ f"Invalid label_kmeans_metric {label_kmeans_metric!r}. "
f"Unsupported: {', '.join(QuickAdapterRegressorV3._UNSUPPORTED_CLUSTER_METRICS)}"
)
cdist_kwargs: dict[str, Any] = {}
]
else:
raise ValueError(
- f"Invalid label_kmeans_selection '{label_kmeans_selection}'. "
+ f"Invalid label_kmeans_selection {label_kmeans_selection!r}. "
f"Supported: {', '.join(QuickAdapterRegressorV3._CLUSTER_SELECTION_METHODS)}"
)
return trial_distances
in QuickAdapterRegressorV3._unsupported_cluster_metrics_set()
):
raise ValueError(
- f"Invalid label_kmedoids_metric '{label_kmedoids_metric}'. "
+ f"Invalid label_kmedoids_metric {label_kmedoids_metric!r}. "
f"Unsupported: {', '.join(QuickAdapterRegressorV3._UNSUPPORTED_CLUSTER_METRICS)}"
)
kmedoids_kwargs: dict[str, Any] = {
]
else:
raise ValueError(
- f"Invalid label_kmedoids_selection '{label_kmedoids_selection}'. "
+ f"Invalid label_kmedoids_selection {label_kmedoids_selection!r}. "
f"Supported: {', '.join(QuickAdapterRegressorV3._CLUSTER_SELECTION_METHODS)}"
)
return trial_distances
return np.nanmax(neighbor_distances, axis=1)
else:
raise ValueError(
- f"Invalid label metric '{metric}'. Supported: {', '.join(metrics)}"
+ f"Invalid label metric {metric!r}. Supported: {', '.join(metrics)}"
)
def _get_multi_objective_study_best_trial(
QuickAdapterRegressorV3._OPTUNA_NAMESPACES[2]
}: # Only "label"
raise ValueError(
- f"Invalid namespace '{namespace}'. "
+ f"Invalid namespace {namespace!r}. "
f"Supported: {QuickAdapterRegressorV3._OPTUNA_NAMESPACES[2]}" # Only label
)
n_objectives = len(study.directions)
) # "euclidean"
if label_metric not in metrics:
raise ValueError(
- f"Invalid label_metric '{label_metric}'. Supported: {', '.join(metrics)}"
+ f"Invalid label_metric {label_metric!r}. Supported: {', '.join(metrics)}"
)
best_trials = [
}
metric_log_msg = f" using {self.ft_params.get('label_metric', QuickAdapterRegressorV3._SCIPY_METRICS[2])} metric"
logger.info(
- f"[{pair}] Optuna {namespace} {objective_type} objective hyperopt done{metric_log_msg} ({time_spent:.2f} secs)"
+ f"[{pair}] Optuna {namespace} {objective_type} objective hyperopt completed{metric_log_msg} ({time_spent:.2f} secs)"
)
for key, value in study_best_results.items():
if isinstance(value, list):
)
else:
raise ValueError(
- f"Invalid optuna storage_backend '{storage_backend}'. "
+ f"Invalid optuna storage_backend {storage_backend!r}. "
f"Supported: {', '.join(QuickAdapterRegressorV3._OPTUNA_STORAGE_BACKENDS)}"
)
return storage
)
else:
raise ValueError(
- f"Invalid optuna sampler '{sampler}'. "
+ f"Invalid optuna sampler {sampler!r}. "
f"Supported: {', '.join(QuickAdapterRegressorV3._OPTUNA_SAMPLERS)}"
)
optuna.delete_study(study_name=study_name, storage=storage)
except Exception as e:
logger.warning(
- f"Optuna study deletion failed for study {study_name}: {e!r}",
+ f"Optuna study {study_name} deletion failed: {e!r}",
exc_info=True,
)
def get_label_natr_ratio_percent(self, pair: str, percent: float) -> float:
if not isinstance(percent, float) or not (0.0 <= percent <= 1.0):
raise ValueError(
- f"Invalid percent {percent}: must be a float between 0 and 1"
+ f"Invalid percent {percent!r}: must be a float in range [0, 1]"
)
return self.get_label_natr_ratio(pair) * percent
or weighting_mmad_scaling_factor <= 0
):
logger.warning(
- f"Invalid extrema_weighting mmad_scaling_factor {weighting_mmad_scaling_factor!r}, must be > 0, using default {DEFAULTS_EXTREMA_WEIGHTING['mmad_scaling_factor']!r}"
+ f"Invalid extrema_weighting mmad_scaling_factor {weighting_mmad_scaling_factor!r}, must be a finite number > 0, using default {DEFAULTS_EXTREMA_WEIGHTING['mmad_scaling_factor']!r}"
)
weighting_mmad_scaling_factor = DEFAULTS_EXTREMA_WEIGHTING[
"mmad_scaling_factor"
or weighting_sigmoid_scale <= 0
):
logger.warning(
- f"Invalid extrema_weighting sigmoid_scale {weighting_sigmoid_scale!r}, must be > 0, using default {DEFAULTS_EXTREMA_WEIGHTING['sigmoid_scale']!r}"
+ f"Invalid extrema_weighting sigmoid_scale {weighting_sigmoid_scale!r}, must be a finite number > 0, using default {DEFAULTS_EXTREMA_WEIGHTING['sigmoid_scale']!r}"
)
weighting_sigmoid_scale = DEFAULTS_EXTREMA_WEIGHTING["sigmoid_scale"]
or weighting_softmax_temperature <= 0
):
logger.warning(
- f"Invalid extrema_weighting softmax_temperature {weighting_softmax_temperature!r}, must be > 0, using default {DEFAULTS_EXTREMA_WEIGHTING['softmax_temperature']!r}"
+ f"Invalid extrema_weighting softmax_temperature {weighting_softmax_temperature!r}, must be a finite number > 0, using default {DEFAULTS_EXTREMA_WEIGHTING['softmax_temperature']!r}"
)
weighting_softmax_temperature = DEFAULTS_EXTREMA_WEIGHTING[
"softmax_temperature"
or not np.isfinite(smoothing_sigma)
):
logger.warning(
- f"Invalid extrema_smoothing sigma {smoothing_sigma!r}, must be a positive finite number, using default {DEFAULTS_EXTREMA_SMOOTHING['sigma']!r}"
+ f"Invalid extrema_smoothing sigma {smoothing_sigma!r}, must be a finite number > 0, using default {DEFAULTS_EXTREMA_SMOOTHING['sigma']!r}"
)
smoothing_sigma = DEFAULTS_EXTREMA_SMOOTHING["sigma"]
try:
return pattern.format(**duration)
except (KeyError, ValueError) as e:
- raise ValueError(f"Invalid pattern '{pattern}': {e!r}")
+ raise ValueError(f"Invalid pattern {pattern!r}: {e!r}")
def set_freqai_targets(
self, dataframe: DataFrame, metadata: dict[str, Any], **kwargs
trade_price_target_fn = trade_price_target_methods.get(trade_price_target)
if trade_price_target_fn is None:
raise ValueError(
- f"Invalid trade_price_target '{trade_price_target}'. "
- f"Supported: {', '.join(sorted(TRADE_PRICE_TARGETS))}"
+ f"Invalid trade_price_target {trade_price_target!r}. "
+ f"Supported: {', '.join(TRADE_PRICE_TARGETS)}"
)
return trade_price_target_fn()
) -> Optional[float]:
if not (0.0 <= natr_ratio_percent <= 1.0):
raise ValueError(
- f"Invalid natr_ratio_percent {natr_ratio_percent}: must be in [0, 1]"
+ f"Invalid natr_ratio_percent {natr_ratio_percent!r}: must be in range [0, 1]"
)
trade_duration_candles = self.get_trade_duration_candles(df, trade)
if not QuickAdapterV3.is_trade_duration_valid(trade_duration_candles):
) -> Optional[float]:
if not (0.0 <= natr_ratio_percent <= 1.0):
raise ValueError(
- f"Invalid natr_ratio_percent {natr_ratio_percent}: must be in [0, 1]"
+ f"Invalid natr_ratio_percent {natr_ratio_percent!r}: must be in range [0, 1]"
)
trade_duration_candles = self.get_trade_duration_candles(df, trade)
if not QuickAdapterV3.is_trade_duration_valid(trade_duration_candles):
)
else:
raise ValueError(
- f"Invalid interpolation_direction '{interpolation_direction}'. "
+ f"Invalid interpolation_direction {interpolation_direction!r}. "
f"Supported: {', '.join(QuickAdapterV3._INTERPOLATION_DIRECTIONS)}"
)
candle_deviation = (
candle_threshold = base_price * (1 - current_deviation)
else:
raise ValueError(
- f"Invalid side '{side}'. Supported: {', '.join(QuickAdapterV3._TRADE_DIRECTIONS)}"
+ f"Invalid side {side!r}. Supported: {', '.join(QuickAdapterV3._TRADE_DIRECTIONS)}"
)
self._candle_threshold_cache[cache_key] = candle_threshold
return self._candle_threshold_cache[cache_key]
if lookback_period > max_lookback_period:
lookback_period = max_lookback_period
if not isinstance(decay_ratio, (int, float)):
- logger.info(
+ logger.debug(
f"[{pair}] Denied {trade_direction} {order}: invalid decay_ratio type"
)
return False
if not (0.0 < decay_ratio <= 1.0):
- logger.info(
+ logger.debug(
f"[{pair}] Denied {trade_direction} {order}: invalid decay_ratio {decay_ratio}, must be in (0, 1]"
)
return False
if side == QuickAdapterV3._TRADE_DIRECTIONS[1]: # "short"
trade_direction = QuickAdapterV3._TRADE_DIRECTIONS[0] # "long"
if not current_ok:
- logger.info(
+ logger.debug(
f"[{pair}] Denied {trade_direction} {order}: rate {format_number(rate)} did not break threshold {format_number(current_threshold)}"
)
return False
side == QuickAdapterV3._TRADE_DIRECTIONS[1]
and not (close_k < threshold_k) # "short"
):
- logger.info(
+ logger.debug(
f"[{pair}] Denied {trade_direction} {order}: "
f"close_k[{-k}] {format_number(close_k)} "
f"did not break threshold_k[{-(k + 1)}] {format_number(threshold_k)} "
return False
else:
raise ValueError(
- f"Invalid trading_mode '{trading_mode}'. "
+ f"Invalid trading_mode {trading_mode!r}. "
f"Supported: {', '.join(QuickAdapterV3._TRADING_MODES)}"
)
@lru_cache(maxsize=8)
def get_odd_window(window: int) -> int:
if window < 1:
- raise ValueError(f"Invalid window {window}: must be > 0")
+ raise ValueError(f"Invalid window {window!r}: must be > 0")
return window if window % 2 == 1 else window + 1
coeffs = sp.signal.windows.triang(M=window, sym=True)
else:
raise ValueError(
- f"Invalid window type '{win_type}'. "
+ f"Invalid window type {win_type!r}. "
f"Supported: {', '.join(SMOOTHING_METHODS[:3])}"
)
return coeffs / np.sum(coeffs)
else:
raise ValueError(
- f"Invalid standardization method '{method}'. "
+ f"Invalid standardization method {method!r}. "
f"Supported: {', '.join(STANDARDIZATION_TYPES)}"
)
normalized_weights = _normalize_rank(standardized_weights, method=rank_method)
else:
raise ValueError(
- f"Invalid normalization method '{normalization}'. "
+ f"Invalid normalization method {normalization!r}. "
f"Supported: {', '.join(NORMALIZATION_TYPES)}"
)
)
else:
raise ValueError(
- f"Invalid hybrid aggregation method '{aggregation}'. "
+ f"Invalid hybrid aggregation method {aggregation!r}. "
f"Supported: {', '.join(HYBRID_AGGREGATIONS)}"
)
)
raise ValueError(
- f"Invalid extrema weighting strategy '{strategy}'. "
+ f"Invalid extrema weighting strategy {strategy!r}. "
f"Supported: {', '.join(WEIGHT_STRATEGIES)}"
)
:return: The top change percentage series
"""
if period < 1:
- raise ValueError(f"Invalid period {period}: must be >= 1")
+ raise ValueError(f"Invalid period {period!r}: must be >= 1")
previous_close_top = (
dataframe.get("close").rolling(period, min_periods=period).max().shift(1)
:return: The bottom change percentage series
"""
if period < 1:
- raise ValueError(f"Invalid period {period}: must be >= 1")
+ raise ValueError(f"Invalid period {period!r}: must be >= 1")
previous_close_bottom = (
dataframe.get("close").rolling(period, min_periods=period).min().shift(1)
:return: Retracement percentage series
"""
if period < 1:
- raise ValueError(f"Invalid period {period}: must be >= 1")
+ raise ValueError(f"Invalid period {period!r}: must be >= 1")
previous_close_low = (
dataframe.get("close").rolling(period, min_periods=period).min().shift(1)
) -> float:
"""Original fractal dimension computation implementation per Ehlers' paper."""
if period % 2 != 0:
- raise ValueError(f"Invalid period {period}: must be even")
+ raise ValueError(f"Invalid period {period!r}: must be even")
half_period = period // 2
Original FRAMA implementation per Ehlers' paper with optional zero lag.
"""
if period % 2 != 0:
- raise ValueError(f"Invalid period {period}: must be even")
+ raise ValueError(f"Invalid period {period!r}: must be even")
n = len(df)
https://www.sierrachart.com/index.php?page=doc/StudiesReference.php&ID=173&Name=Moving_Average_-_Smoothed
"""
if period <= 0:
- raise ValueError(f"Invalid period {period}: must be > 0")
+ raise ValueError(f"Invalid period {period!r}: must be > 0")
n = len(series)
if n < period:
return pd.Series(index=series.index, dtype=float)
]
else:
raise ValueError(
- f"Invalid regressor '{regressor}'. Supported: {', '.join(REGRESSORS)}"
+ f"Invalid regressor {regressor!r}. Supported: {', '.join(REGRESSORS)}"
)
return callbacks
)
else:
raise ValueError(
- f"Invalid regressor '{regressor}'. Supported: {', '.join(REGRESSORS)}"
+ f"Invalid regressor {regressor!r}. Supported: {', '.join(REGRESSORS)}"
)
return model
) -> dict[str, Any]:
if regressor not in set(REGRESSORS):
raise ValueError(
- f"Invalid regressor '{regressor}'. Supported: {', '.join(REGRESSORS)}"
+ f"Invalid regressor {regressor!r}. Supported: {', '.join(REGRESSORS)}"
)
if not isinstance(expansion_ratio, (int, float)) or not (
0.0 <= expansion_ratio <= 1.0
):
raise ValueError(
- f"Invalid expansion_ratio {expansion_ratio}: must be a float between 0 and 1"
+ f"Invalid expansion_ratio {expansion_ratio!r}: must be in range [0, 1]"
)
default_ranges: dict[str, tuple[float, float]] = {
"n_estimators": (100, 2000),
repositories / freqai-strategies.git / commitdiff
