3e0e89b826
- Introduced dynamic generation of parameter fields and callback handling for indicators, enhancing modularity and maintainability. - Updated `config_utils.py` with new utility functions to load indicator templates and generate dynamic outputs and states for parameter fields. - Refactored `indicators.py` to utilize these utilities, streamlining the callback logic and improving user experience by reducing hardcoded elements. - Modified `indicator_modal.py` to create parameter fields dynamically based on JSON templates, eliminating the need for manual updates when adding new indicators. - Added documentation outlining the new data-driven architecture for indicators, improving clarity and guidance for future development. These changes significantly enhance the flexibility and scalability of the indicator system, aligning with project goals for maintainability and performance.
421 lines
19 KiB
Python
421 lines
19 KiB
Python
"""
|
|
Indicator-related callbacks for the dashboard.
|
|
"""
|
|
|
|
import dash
|
|
from dash import Output, Input, State, html, dcc, callback_context, no_update
|
|
import dash_bootstrap_components as dbc
|
|
import json
|
|
from utils.logger import get_logger
|
|
from config.indicators.config_utils import (
|
|
get_parameter_field_outputs,
|
|
get_parameter_field_states,
|
|
get_parameter_field_edit_outputs,
|
|
get_parameter_field_reset_outputs,
|
|
get_parameter_visibility_styles,
|
|
collect_parameter_values,
|
|
set_parameter_values,
|
|
reset_parameter_values
|
|
)
|
|
|
|
logger = get_logger("default_logger")
|
|
|
|
|
|
def register_indicator_callbacks(app):
|
|
"""Register indicator-related callbacks."""
|
|
|
|
# Modal control callbacks
|
|
@app.callback(
|
|
Output('indicator-modal', 'is_open'),
|
|
[Input('add-indicator-btn-visible', 'n_clicks'),
|
|
Input('cancel-indicator-btn', 'n_clicks'),
|
|
Input('save-indicator-btn', 'n_clicks'),
|
|
Input({'type': 'edit-indicator-btn', 'index': dash.ALL}, 'n_clicks')],
|
|
[State('indicator-modal', 'is_open')],
|
|
prevent_initial_call=True
|
|
)
|
|
def toggle_indicator_modal(add_clicks, cancel_clicks, save_clicks, edit_clicks, is_open):
|
|
"""Toggle the visibility of the add indicator modal."""
|
|
ctx = callback_context
|
|
if not ctx.triggered:
|
|
return is_open
|
|
|
|
triggered_id = ctx.triggered[0]['prop_id'].split('.')[0]
|
|
|
|
# Check for add button click
|
|
if triggered_id == 'add-indicator-btn-visible' and add_clicks:
|
|
return True
|
|
|
|
# Check for edit button clicks, ensuring a click actually happened
|
|
if 'edit-indicator-btn' in triggered_id and any(c for c in edit_clicks if c is not None):
|
|
return True
|
|
|
|
# Check for cancel or save clicks to close the modal
|
|
if triggered_id in ['cancel-indicator-btn', 'save-indicator-btn']:
|
|
return False
|
|
|
|
return is_open
|
|
|
|
# Update parameter fields based on indicator type - now fully dynamic!
|
|
@app.callback(
|
|
get_parameter_field_outputs(),
|
|
Input('indicator-type-dropdown', 'value'),
|
|
prevent_initial_call=True
|
|
)
|
|
def update_parameter_fields(indicator_type):
|
|
"""Show/hide parameter input fields based on selected indicator type."""
|
|
return get_parameter_visibility_styles(indicator_type)
|
|
|
|
# Save indicator callback - now fully dynamic!
|
|
@app.callback(
|
|
[Output('save-indicator-feedback', 'children'),
|
|
Output('overlay-indicators-checklist', 'options'),
|
|
Output('subplot-indicators-checklist', 'options')],
|
|
Input('save-indicator-btn', 'n_clicks'),
|
|
[State('indicator-name-input', 'value'),
|
|
State('indicator-type-dropdown', 'value'),
|
|
State('indicator-description-input', 'value'),
|
|
State('indicator-timeframe-dropdown', 'value'),
|
|
State('indicator-color-input', 'value'),
|
|
State('indicator-line-width-slider', 'value'),
|
|
State('edit-indicator-store', 'data')] + get_parameter_field_states(),
|
|
prevent_initial_call=True
|
|
)
|
|
def save_new_indicator(n_clicks, name, indicator_type, description, timeframe, color, line_width, edit_data, *parameter_values):
|
|
"""Save a new indicator or update an existing one."""
|
|
if not n_clicks or not name or not indicator_type:
|
|
return "", no_update, no_update
|
|
|
|
try:
|
|
# Get indicator manager
|
|
from components.charts.indicator_manager import get_indicator_manager
|
|
manager = get_indicator_manager()
|
|
|
|
# Create mapping of parameter field IDs to values
|
|
parameter_states = get_parameter_field_states()
|
|
all_parameter_values = {}
|
|
for i, state in enumerate(parameter_states):
|
|
if i < len(parameter_values):
|
|
field_id = state.component_id
|
|
all_parameter_values[field_id] = parameter_values[i]
|
|
|
|
# Collect parameters for the specific indicator type
|
|
parameters = collect_parameter_values(indicator_type, all_parameter_values)
|
|
|
|
feedback_msg = None
|
|
# Check if this is an edit operation
|
|
is_edit = edit_data and edit_data.get('mode') == 'edit'
|
|
|
|
if is_edit:
|
|
# Update existing indicator
|
|
indicator_id = edit_data.get('indicator_id')
|
|
success = manager.update_indicator(
|
|
indicator_id,
|
|
name=name,
|
|
description=description or "",
|
|
parameters=parameters,
|
|
styling={'color': color or "#007bff", 'line_width': line_width or 2},
|
|
timeframe=timeframe or None
|
|
)
|
|
|
|
if success:
|
|
feedback_msg = dbc.Alert(f"Indicator '{name}' updated successfully!", color="success")
|
|
else:
|
|
feedback_msg = dbc.Alert("Failed to update indicator.", color="danger")
|
|
return feedback_msg, no_update, no_update
|
|
else:
|
|
# Create new indicator
|
|
new_indicator = manager.create_indicator(
|
|
name=name,
|
|
indicator_type=indicator_type,
|
|
parameters=parameters,
|
|
description=description or "",
|
|
color=color or "#007bff",
|
|
timeframe=timeframe or None
|
|
)
|
|
|
|
if not new_indicator:
|
|
feedback_msg = dbc.Alert("Failed to save indicator.", color="danger")
|
|
return feedback_msg, no_update, no_update
|
|
|
|
feedback_msg = dbc.Alert(f"Indicator '{name}' saved successfully!", color="success")
|
|
|
|
# Refresh the indicator options
|
|
overlay_indicators = manager.get_indicators_by_type('overlay')
|
|
subplot_indicators = manager.get_indicators_by_type('subplot')
|
|
|
|
overlay_options = []
|
|
for indicator in overlay_indicators:
|
|
display_name = f"{indicator.name} ({indicator.type.upper()})"
|
|
overlay_options.append({'label': display_name, 'value': indicator.id})
|
|
|
|
subplot_options = []
|
|
for indicator in subplot_indicators:
|
|
display_name = f"{indicator.name} ({indicator.type.upper()})"
|
|
subplot_options.append({'label': display_name, 'value': indicator.id})
|
|
|
|
return feedback_msg, overlay_options, subplot_options
|
|
|
|
except Exception as e:
|
|
logger.error(f"Indicator callback: Error saving indicator: {e}")
|
|
error_msg = dbc.Alert(f"Error: {str(e)}", color="danger")
|
|
return error_msg, no_update, no_update
|
|
|
|
# Update custom indicator lists with edit/delete buttons
|
|
@app.callback(
|
|
[Output('overlay-indicators-list', 'children'),
|
|
Output('subplot-indicators-list', 'children')],
|
|
[Input('overlay-indicators-checklist', 'options'),
|
|
Input('subplot-indicators-checklist', 'options'),
|
|
Input('overlay-indicators-checklist', 'value'),
|
|
Input('subplot-indicators-checklist', 'value')]
|
|
)
|
|
def update_custom_indicator_lists(overlay_options, subplot_options, overlay_values, subplot_values):
|
|
"""Create custom indicator lists with edit and delete buttons."""
|
|
|
|
def create_indicator_item(option, is_checked):
|
|
"""Create a single indicator item with checkbox and buttons."""
|
|
indicator_id = option['value']
|
|
indicator_name = option['label']
|
|
|
|
return html.Div([
|
|
# Checkbox and name
|
|
html.Div([
|
|
dcc.Checklist(
|
|
options=[{'label': '', 'value': indicator_id}],
|
|
value=[indicator_id] if is_checked else [],
|
|
id={'type': 'indicator-checkbox', 'index': indicator_id},
|
|
style={'display': 'inline-block', 'margin-right': '8px'}
|
|
),
|
|
html.Span(indicator_name, style={'display': 'inline-block', 'vertical-align': 'top'})
|
|
], style={'display': 'inline-block', 'width': '70%'}),
|
|
|
|
# Edit and Delete buttons
|
|
html.Div([
|
|
html.Button(
|
|
"✏️",
|
|
id={'type': 'edit-indicator-btn', 'index': indicator_id},
|
|
title="Edit indicator",
|
|
className="btn btn-sm btn-outline-primary",
|
|
style={'margin-left': '5px'}
|
|
),
|
|
html.Button(
|
|
"🗑️",
|
|
id={'type': 'delete-indicator-btn', 'index': indicator_id},
|
|
title="Delete indicator",
|
|
className="btn btn-sm btn-outline-danger",
|
|
style={'margin-left': '5px'}
|
|
)
|
|
], style={'display': 'inline-block', 'width': '30%', 'text-align': 'right'})
|
|
], style={
|
|
'display': 'block',
|
|
'padding': '5px 0',
|
|
'border-bottom': '1px solid #f0f0f0',
|
|
'margin-bottom': '5px'
|
|
})
|
|
|
|
# Create overlay indicators list
|
|
overlay_list = []
|
|
for option in overlay_options:
|
|
is_checked = option['value'] in (overlay_values or [])
|
|
overlay_list.append(create_indicator_item(option, is_checked))
|
|
|
|
# Create subplot indicators list
|
|
subplot_list = []
|
|
for option in subplot_options:
|
|
is_checked = option['value'] in (subplot_values or [])
|
|
subplot_list.append(create_indicator_item(option, is_checked))
|
|
|
|
return overlay_list, subplot_list
|
|
|
|
# Sync individual indicator checkboxes with main checklist
|
|
@app.callback(
|
|
Output('overlay-indicators-checklist', 'value', allow_duplicate=True),
|
|
[Input({'type': 'indicator-checkbox', 'index': dash.ALL}, 'value')],
|
|
[State('overlay-indicators-checklist', 'options')],
|
|
prevent_initial_call=True
|
|
)
|
|
def sync_overlay_indicators(checkbox_values, overlay_options):
|
|
"""Sync individual indicator checkboxes with main overlay checklist."""
|
|
if not checkbox_values or not overlay_options:
|
|
return []
|
|
|
|
selected_indicators = []
|
|
overlay_ids = [opt['value'] for opt in overlay_options]
|
|
|
|
# Flatten the checkbox values and filter for overlay indicators
|
|
for values in checkbox_values:
|
|
if values: # values is a list, check if not empty
|
|
for indicator_id in values:
|
|
if indicator_id in overlay_ids:
|
|
selected_indicators.append(indicator_id)
|
|
|
|
# Remove duplicates
|
|
return list(set(selected_indicators))
|
|
|
|
@app.callback(
|
|
Output('subplot-indicators-checklist', 'value', allow_duplicate=True),
|
|
[Input({'type': 'indicator-checkbox', 'index': dash.ALL}, 'value')],
|
|
[State('subplot-indicators-checklist', 'options')],
|
|
prevent_initial_call=True
|
|
)
|
|
def sync_subplot_indicators(checkbox_values, subplot_options):
|
|
"""Sync individual indicator checkboxes with main subplot checklist."""
|
|
if not checkbox_values or not subplot_options:
|
|
return []
|
|
|
|
selected_indicators = []
|
|
subplot_ids = [opt['value'] for opt in subplot_options]
|
|
|
|
# Flatten the checkbox values and filter for subplot indicators
|
|
for values in checkbox_values:
|
|
if values: # values is a list, check if not empty
|
|
for indicator_id in values:
|
|
if indicator_id in subplot_ids:
|
|
selected_indicators.append(indicator_id)
|
|
|
|
# Remove duplicates
|
|
return list(set(selected_indicators))
|
|
|
|
# Handle delete indicator
|
|
@app.callback(
|
|
[Output('save-indicator-feedback', 'children', allow_duplicate=True),
|
|
Output('overlay-indicators-checklist', 'options', allow_duplicate=True),
|
|
Output('subplot-indicators-checklist', 'options', allow_duplicate=True)],
|
|
[Input({'type': 'delete-indicator-btn', 'index': dash.ALL}, 'n_clicks')],
|
|
[State({'type': 'delete-indicator-btn', 'index': dash.ALL}, 'id')],
|
|
prevent_initial_call=True
|
|
)
|
|
def delete_indicator(delete_clicks, button_ids):
|
|
"""Delete an indicator when delete button is clicked."""
|
|
ctx = callback_context
|
|
if not ctx.triggered or not any(delete_clicks):
|
|
return no_update, no_update, no_update
|
|
|
|
# Find which button was clicked
|
|
triggered_id = ctx.triggered[0]['prop_id']
|
|
button_info = json.loads(triggered_id.split('.')[0])
|
|
indicator_id = button_info['index']
|
|
|
|
try:
|
|
# Get indicator manager and delete the indicator
|
|
from components.charts.indicator_manager import get_indicator_manager
|
|
manager = get_indicator_manager()
|
|
|
|
# Load indicator to get its name before deletion
|
|
indicator = manager.load_indicator(indicator_id)
|
|
indicator_name = indicator.name if indicator else indicator_id
|
|
|
|
if manager.delete_indicator(indicator_id):
|
|
# Refresh the indicator options
|
|
overlay_indicators = manager.get_indicators_by_type('overlay')
|
|
subplot_indicators = manager.get_indicators_by_type('subplot')
|
|
|
|
overlay_options = []
|
|
for indicator in overlay_indicators:
|
|
display_name = f"{indicator.name} ({indicator.type.upper()})"
|
|
overlay_options.append({'label': display_name, 'value': indicator.id})
|
|
|
|
subplot_options = []
|
|
for indicator in subplot_indicators:
|
|
display_name = f"{indicator.name} ({indicator.type.upper()})"
|
|
subplot_options.append({'label': display_name, 'value': indicator.id})
|
|
|
|
success_msg = dbc.Alert(f"Indicator '{indicator_name}' deleted.", color="warning")
|
|
|
|
return success_msg, overlay_options, subplot_options
|
|
else:
|
|
error_msg = dbc.Alert("Failed to delete indicator.", color="danger")
|
|
return error_msg, no_update, no_update
|
|
|
|
except Exception as e:
|
|
logger.error(f"Indicator callback: Error deleting indicator: {e}")
|
|
error_msg = dbc.Alert(f"Error: {str(e)}", color="danger")
|
|
return error_msg, no_update, no_update
|
|
|
|
# Handle edit indicator - open modal with existing data - now fully dynamic!
|
|
@app.callback(
|
|
[Output('modal-title', 'children'),
|
|
Output('indicator-name-input', 'value'),
|
|
Output('indicator-type-dropdown', 'value'),
|
|
Output('indicator-description-input', 'value'),
|
|
Output('indicator-timeframe-dropdown', 'value'),
|
|
Output('indicator-color-input', 'value'),
|
|
Output('edit-indicator-store', 'data')] + get_parameter_field_edit_outputs(),
|
|
[Input({'type': 'edit-indicator-btn', 'index': dash.ALL}, 'n_clicks')],
|
|
[State({'type': 'edit-indicator-btn', 'index': dash.ALL}, 'id')],
|
|
prevent_initial_call=True
|
|
)
|
|
def edit_indicator(edit_clicks, button_ids):
|
|
"""Load indicator data for editing."""
|
|
ctx = callback_context
|
|
if not ctx.triggered or not any(edit_clicks):
|
|
# Return the correct number of no_updates for all outputs
|
|
basic_outputs = 7 # Modal title, name, type, description, timeframe, color, edit_data
|
|
parameter_outputs = len(get_parameter_field_edit_outputs())
|
|
return [no_update] * (basic_outputs + parameter_outputs)
|
|
|
|
# Find which button was clicked
|
|
triggered_id = ctx.triggered[0]['prop_id']
|
|
button_info = json.loads(triggered_id.split('.')[0])
|
|
indicator_id = button_info['index']
|
|
|
|
try:
|
|
# Load the indicator data
|
|
from components.charts.indicator_manager import get_indicator_manager
|
|
manager = get_indicator_manager()
|
|
indicator = manager.load_indicator(indicator_id)
|
|
|
|
if indicator:
|
|
# Store indicator ID for update
|
|
edit_data = {'indicator_id': indicator_id, 'mode': 'edit'}
|
|
|
|
# Generate parameter values for all fields
|
|
parameter_values = set_parameter_values(indicator.type, indicator.parameters)
|
|
|
|
# Return all values: basic fields + dynamic parameter fields
|
|
return (
|
|
[f"✏️ Edit Indicator: {indicator.name}",
|
|
indicator.name,
|
|
indicator.type,
|
|
indicator.description,
|
|
indicator.timeframe,
|
|
indicator.styling.color,
|
|
edit_data] + parameter_values
|
|
)
|
|
else:
|
|
basic_outputs = 7
|
|
parameter_outputs = len(get_parameter_field_edit_outputs())
|
|
return [no_update] * (basic_outputs + parameter_outputs)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Indicator callback: Error loading indicator for edit: {e}")
|
|
basic_outputs = 7
|
|
parameter_outputs = len(get_parameter_field_edit_outputs())
|
|
return [no_update] * (basic_outputs + parameter_outputs)
|
|
|
|
# Reset modal form when closed or saved - now fully dynamic!
|
|
@app.callback(
|
|
[Output('indicator-name-input', 'value', allow_duplicate=True),
|
|
Output('indicator-type-dropdown', 'value', allow_duplicate=True),
|
|
Output('indicator-description-input', 'value', allow_duplicate=True),
|
|
Output('indicator-timeframe-dropdown', 'value', allow_duplicate=True),
|
|
Output('indicator-color-input', 'value', allow_duplicate=True),
|
|
Output('indicator-line-width-slider', 'value'),
|
|
Output('modal-title', 'children', allow_duplicate=True),
|
|
Output('edit-indicator-store', 'data', allow_duplicate=True)] + get_parameter_field_reset_outputs(),
|
|
[Input('cancel-indicator-btn', 'n_clicks'),
|
|
Input('save-indicator-btn', 'n_clicks')], # Also reset on successful save
|
|
prevent_initial_call=True
|
|
)
|
|
def reset_modal_form(cancel_clicks, save_clicks):
|
|
"""Reset the modal form to its default state."""
|
|
# Basic form reset values
|
|
basic_values = ["", "", "", "", "", 2, "📊 Add New Indicator", None]
|
|
|
|
# Dynamic parameter reset values
|
|
parameter_values = reset_parameter_values()
|
|
|
|
return basic_values + parameter_values
|
|
|
|
logger.info("Indicator callbacks: registered successfully") |