Error when filtering values of a line plot when deploying app: WARN: unrecognized GUI edit: selections[0].y1

Dash Python
,
1

In my app, I have a clientside_callback function that filters data in a line plot and updates some card values. While it works locally, it fails when running in Docker on my virtual machine, and I’m unsure why. When applying a filter in the plot, I receive the following warning:

WARN: unrecognized GUI edit: selections[0].x1
WARN: unrecognized GUI edit: selections[0].y1

This is the clientside function that updates the plot:

window.dash_clientside = Object.assign({}, window.dash_clientside, {
    clientside_card: {
        filter_cards: function(
            ua_value,
            cluster_value,
            porte_value,
            prod_value,
            coop_value,
            selected_data_ts,
            filtered_data_comp,
            filtered_data_prev,
            model_selected,
            theme
        ) {
            const required_values = [
                ua_value,
                cluster_value,
                porte_value,
                "25% melhores UAs",
                prod_value,
                coop_value
            ];

            const isPlotlyDark = theme === "plotly_dark";
            const emptyValues = Array(8).fill("vazio");
            const colors = Array(8).fill(isPlotlyDark ? "white" : "");

            if (!required_values.every(Boolean)) {
                return emptyValues.concat(colors);
            }

            const df_comp = (() => {
                if (
                    filtered_data_comp &&
                    typeof filtered_data_comp === "object" &&
                    !Array.isArray(filtered_data_comp)
                ) {
                    const keys = Object.keys(filtered_data_comp);
                    const indices = Object.keys(filtered_data_comp[keys[0]]);
                    return indices.map(idx => {
                        const row = {};
                        keys.forEach(k => {
                            row[k] = filtered_data_comp[k][idx];
                        });
                        return row;
                    });
                }
                return [];
            })();


            const df_prev = Array.isArray(filtered_data_prev) ? filtered_data_prev : [];

            const modelFilters = Array.isArray(model_selected) ? model_selected.map(m => m.split("|")) : [];

            const df_prev_filtered = df_prev.filter(row =>
                modelFilters.some(([uid, model]) =>
                    row["unique_id"] === uid && row["modelos"] === model
                )
            );

            const filterConditions = {
                "ua": ua_value,
                "25": "25%",
                "cluster": cluster_value,
                "porte": porte_value
            };

            function filterData(df) {
                const result = {};
                for (const [key, value] of Object.entries(filterConditions)) {
                    result[key] = df.filter(row =>
                        typeof row["unique_id"] === "string" && row["unique_id"].includes(value)
                    );
                }
                return result;
            }

            let filtered_dfs = {
                "comp": filterData(df_comp),
                "prev": filterData(df_prev_filtered)
            };

            if (
                selected_data_ts &&
                selected_data_ts["points"] &&
                Array.isArray(selected_data_ts["points"])
            ) {
                const selectedDates = new Set(
                    selected_data_ts["points"].map(p => p.x)
                );

                for (const key of ["comp", "prev"]) {
                    for (const subkey in filtered_dfs[key]) {
                        filtered_dfs[key][subkey] = filtered_dfs[key][subkey].filter(
                            row => selectedDates.has(row["ds"])
                        );
                    }
                }
            }

            function sumField(dataArray, field) {
                return dataArray.reduce((acc, row) => acc + (parseFloat(row[field]) || 0), 0);
            }

            const prevResults = Object.values(filtered_dfs["prev"]).map(df =>
                sumField(df, "Previsão").toFixed(2)
            );
            const compResults = Object.values(filtered_dfs["comp"]).map(df =>
                sumField(df, "y").toFixed(2)
            );

            return prevResults.concat(compResults, colors);
        }
    }
});