Delete components

components/analysis.py

@@ -1,90 +0,0 @@
-# components/analysis.py
-
-from typing import Dict, Optional
-import pandas as pd
-
-from .statistical import StatisticalAnalyzer
-from .visualization import D3Visualizer
-
-class DataAnalyzer:
-    """Main analysis component with datetime handling"""
-    
-    def __init__(self):
-        self.statistical = StatisticalAnalyzer()
-        self.visualizer = D3Visualizer()
-        
-    def analyze_data(
-        self, 
-        df: pd.DataFrame,
-        analysis_type: str,
-        params: Optional[Dict] = None
-    ) -> Dict:
-        """Analyze data based on type"""
-        params = params or {}
-        
-        try:
-            if analysis_type == "distribution":
-                # Select column or default to first numeric column
-                column = params.get("column")
-                if not column or column not in df.columns:
-                    numeric_cols = df.select_dtypes(include=['number']).columns
-                    if len(numeric_cols) == 0:
-                        raise ValueError("No numeric columns found for distribution analysis")
-                    column = numeric_cols[0]
-                
-                values = df[column].dropna().values
-                stats_result = self.statistical.analyze_distribution(values)
-                viz_result = self.visualizer.create_interactive_plot(
-                    "distribution",
-                    {"values": values.tolist()}
-                )
-                
-                return {
-                    "statistics": stats_result,
-                    "visualization": viz_result
-                }
-                
-            elif analysis_type == "forecast":
-                # Handle time series data
-                column = params.get("column")
-                if not column or column not in df.columns:
-                    numeric_cols = df.select_dtypes(include=['number']).columns
-                    if len(numeric_cols) == 0:
-                        raise ValueError("No numeric columns found for forecasting")
-                    column = numeric_cols[0]
-                
-                values = df[column].dropna().values
-                forecast_result = self.statistical.forecast_probability_cone(
-                    values,
-                    steps=params.get("steps", 10)
-                )
-                viz_result = self.visualizer.create_interactive_plot(
-                    "forecast",
-                    forecast_result
-                )
-                
-                return {
-                    "forecast": forecast_result,
-                    "visualization": viz_result
-                }
-                
-            elif analysis_type == "correlation":
-                # Analyze correlations (datetime columns are handled in StatisticalAnalyzer)
-                corr_result = self.statistical.analyze_correlations(df)
-                viz_result = self.visualizer.create_interactive_plot(
-                    "correlation",
-                    {"matrix": corr_result["correlation_matrix"]}
-                )
-                
-                return {
-                    "correlations": corr_result,
-                    "visualization": viz_result
-                }
-                
-            return {"error": "Unsupported analysis type"}
-            
-        except Exception as e:
-            return {
-                "error": str(e),
-                "visualization": f"<div class='error'>Error in analysis: {str(e)}</div>"
-            }

components/statistical.py

@@ -1,145 +0,0 @@
-# components/statistical.py
-
-import numpy as np
-import pandas as pd
-from scipy import stats
-from typing import Dict, List, Optional, Union
-from datetime import datetime
-
-class StatisticalAnalyzer:
-    """Statistical analysis component with datetime handling"""
-    
-    @staticmethod
-    def preprocess_dataframe(df: pd.DataFrame) -> pd.DataFrame:
-        """Preprocess dataframe to handle datetime columns"""
-        df_numeric = df.copy()
-        
-        for column in df.columns:
-            # Convert datetime columns to timestamps for numerical analysis
-            if pd.api.types.is_datetime64_any_dtype(df[column]) or (
-                isinstance(df[column].iloc[0], str) and 
-                bool(datetime.strptime(df[column].iloc[0], '%Y-%m-%d'))
-            ):
-                try:
-                    df_numeric[column] = pd.to_datetime(df[column]).astype(np.int64) // 10**9
-                except:
-                    # If conversion fails, exclude the column
-                    df_numeric = df_numeric.drop(columns=[column])
-                    
-        return df_numeric
-    
-    @staticmethod
-    def analyze_distribution(values: Union[List[float], np.ndarray]) -> Dict:
-        """Analyze data distribution"""
-        values = np.array(values)
-        if not np.issubdtype(values.dtype, np.number):
-            raise ValueError("Values must be numeric for distribution analysis")
-            
-        result = {
-            "n_samples": len(values),
-            "mean": float(np.mean(values)),
-            "std": float(np.std(values)),
-            "median": float(np.median(values)),
-            "quartiles": [float(np.percentile(values, q)) for q in [25, 50, 75]],
-            "skewness": float(stats.skew(values)),
-            "kurtosis": float(stats.kurtosis(values))
-        }
-        
-        # Test for normality
-        if len(values) >= 3:  # D'Agostino's K^2 test requires at least 3 samples
-            statistic, p_value = stats.normaltest(values)
-            result["normality_test"] = {
-                "statistic": float(statistic),
-                "p_value": float(p_value),
-                "is_normal": p_value > 0.05
-            }
-        
-        return result
-    
-    @staticmethod
-    def calculate_confidence_interval(
-        values: Union[List[float], np.ndarray],
-        confidence: float = 0.95
-    ) -> Dict:
-        """Calculate confidence intervals"""
-        values = np.array(values)
-        if not np.issubdtype(values.dtype, np.number):
-            raise ValueError("Values must be numeric for confidence interval calculation")
-            
-        mean = np.mean(values)
-        std_err = stats.sem(values)
-        ci = stats.t.interval(confidence, len(values)-1, loc=mean, scale=std_err)
-        
-        return {
-            "mean": float(mean),
-            "ci_lower": float(ci[0]),
-            "ci_upper": float(ci[1]),
-            "confidence": confidence
-        }
-    
-    def forecast_probability_cone(
-        self,
-        values: Union[List[float], np.ndarray],
-        steps: int = 10,
-        confidence: float = 0.95
-    ) -> Dict:
-        """Generate probability cone forecast"""
-        values = np.array(values)
-        if not np.issubdtype(values.dtype, np.number):
-            raise ValueError("Values must be numeric for forecasting")
-            
-        # Use exponential smoothing for trend
-        alpha = 0.3
-        smoothed = []
-        s = values[0]
-        for value in values:
-            s = alpha * value + (1-alpha) * s
-            smoothed.append(s)
-            
-        # Calculate errors for confidence intervals
-        errors = values - np.array(smoothed)
-        std_err = np.std(errors)
-        t_value = stats.t.ppf((1 + confidence) / 2, len(values) - 1)
-        
-        # Generate forecast
-        last_smoothed = smoothed[-1]
-        time_points = list(range(steps))
-        forecast = [last_smoothed] * steps
-        
-        # Expanding confidence intervals
-        errors = [t_value * std_err * np.sqrt(1 + i/len(values)) 
-                 for i in range(steps)]
-        
-        return {
-            "time": time_points,
-            "mean": [float(x) for x in forecast],
-            "lower": [float(f - e) for f, e in zip(forecast, errors)],
-            "upper": [float(f + e) for f, e in zip(forecast, errors)]
-        }
-    
-    def analyze_correlations(self, df: pd.DataFrame) -> Dict:
-        """Analyze correlations between numeric variables"""
-        # Preprocess to handle datetime columns
-        df_numeric = self.preprocess_dataframe(df)
-        
-        # Calculate correlations only for numeric columns
-        numeric_cols = df_numeric.select_dtypes(include=[np.number]).columns
-        corr_matrix = df_numeric[numeric_cols].corr()
-        
-        # Find significant correlations
-        significant = []
-        for i in range(len(numeric_cols)):
-            for j in range(i+1, len(numeric_cols)):
-                corr = corr_matrix.iloc[i,j]
-                if abs(corr) > 0.5:  # Threshold for significant correlation
-                    significant.append({
-                        "var1": numeric_cols[i],
-                        "var2": numeric_cols[j],
-                        "correlation": float(corr)
-                    })
-        
-        return {
-            "correlation_matrix": corr_matrix.to_dict(),
-            "significant_correlations": significant,
-            "numeric_columns": list(numeric_cols)
-        }

components/visualization.py

@@ -1,230 +0,0 @@
-# components/visualization.py
-
-class D3Visualizer:
-    """D3.js visualization component"""
-    
-    @staticmethod
-    def create_interactive_plot(plot_type: str, data: dict) -> str:
-        """Create interactive D3 visualization"""
-        
-        # Base CSS for visualizations
-        base_css = """
-        <style>
-            .visualization-container { width: 100%; height: 500px; }
-            .bar { fill: steelblue; }
-            .bar:hover { fill: brown; }
-            .line { fill: none; stroke: steelblue; stroke-width: 2; }
-            .area { fill: steelblue; opacity: 0.2; }
-            .tooltip { position: absolute; padding: 8px; background: white; border: 1px solid #ddd; border-radius: 4px; }
-            .axis-label { font-size: 12px; }
-        </style>
-        """
-
-        if plot_type == "distribution":
-            return base_css + f"""
-            <div id="distribution-plot" class="visualization-container"></div>
-            <script src="https://d3js.org/d3.v7.min.js"></script>
-            <script>
-            (function() {{
-                const values = {data['values']};
-                const margin = {{top: 40, right: 40, bottom: 60, left: 60}};
-                const width = 800 - margin.left - margin.right;
-                const height = 400 - margin.top - margin.bottom;
-
-                // Create SVG
-                const svg = d3.select("#distribution-plot")
-                    .append("svg")
-                    .attr("width", width + margin.left + margin.right)
-                    .attr("height", height + margin.top + margin.bottom)
-                    .append("g")
-                    .attr("transform", `translate(${{margin.left}},${{margin.top}})`);
-
-                // Create scales
-                const x = d3.scaleLinear()
-                    .domain([d3.min(values), d3.max(values)])
-                    .range([0, width]);
-
-                const histogram = d3.histogram()
-                    .domain(x.domain())
-                    .thresholds(x.ticks(20));
-
-                const bins = histogram(values);
-
-                const y = d3.scaleLinear()
-                    .domain([0, d3.max(bins, d => d.length)])
-                    .range([height, 0]);
-
-                // Create bars
-                svg.selectAll(".bar")
-                    .data(bins)
-                    .enter()
-                    .append("rect")
-                    .attr("class", "bar")
-                    .attr("x", d => x(d.x0))
-                    .attr("y", d => y(d.length))
-                    .attr("width", d => Math.max(0, x(d.x1) - x(d.x0) - 1))
-                    .attr("height", d => height - y(d.length))
-                    .on("mouseover", function(event, d) {{
-                        tooltip.transition()
-                            .duration(200)
-                            .style("opacity", .9);
-                        tooltip.html(
-                            `Range: ${{d.x0.toFixed(2)}} - ${{d.x1.toFixed(2)}}<br/>` +
-                            `Count: ${{d.length}}`
-                        )
-                        .style("left", (event.pageX + 5) + "px")
-                        .style("top", (event.pageY - 28) + "px");
-                    }})
-                    .on("mouseout", function(d) {{
-                        tooltip.transition()
-                            .duration(500)
-                            .style("opacity", 0);
-                    }});
-
-                // Add axes
-                svg.append("g")
-                    .attr("class", "x-axis")
-                    .attr("transform", `translate(0,${{height}})`)
-                    .call(d3.axisBottom(x))
-                    .append("text")
-                    .attr("class", "axis-label")
-                    .attr("x", width/2)
-                    .attr("y", 40)
-                    .text("Value");
-
-                svg.append("g")
-                    .attr("class", "y-axis")
-                    .call(d3.axisLeft(y))
-                    .append("text")
-                    .attr("class", "axis-label")
-                    .attr("transform", "rotate(-90)")
-                    .attr("y", -40)
-                    .attr("x", -height/2)
-                    .style("text-anchor", "middle")
-                    .text("Frequency");
-
-                // Add tooltip
-                const tooltip = d3.select("#distribution-plot")
-                    .append("div")
-                    .attr("class", "tooltip")
-                    .style("opacity", 0);
-            }})();
-            </script>
-            """
-
-        elif plot_type == "forecast":
-            return base_css + f"""
-            <div id="forecast-plot" class="visualization-container"></div>
-            <script src="https://d3js.org/d3.v7.min.js"></script>
-            <script>
-            (function() {{
-                const data = {data};
-                const margin = {{top: 40, right: 40, bottom: 60, left: 60}};
-                const width = 800 - margin.left - margin.right;
-                const height = 400 - margin.top - margin.bottom;
-
-                // Create SVG
-                const svg = d3.select("#forecast-plot")
-                    .append("svg")
-                    .attr("width", width + margin.left + margin.right)
-                    .attr("height", height + margin.top + margin.bottom)
-                    .append("g")
-                    .attr("transform", `translate(${{margin.left}},${{margin.top}})`);
-
-                // Create scales
-                const x = d3.scaleLinear()
-                    .domain([0, data.time.length-1])
-                    .range([0, width]);
-
-                const y = d3.scaleLinear()
-                    .domain([
-                        d3.min(data.lower),
-                        d3.max(data.upper)
-                    ])
-                    .range([height, 0]);
-
-                // Create area
-                const area = d3.area()
-                    .x((d, i) => x(i))
-                    .y0(d => y(d[0]))
-                    .y1(d => y(d[1]));
-
-                // Add confidence interval area
-                svg.append("path")
-                    .datum(data.time.map((t, i) => [data.lower[i], data.upper[i]]))
-                    .attr("class", "area")
-                    .attr("d", area);
-
-                // Add mean line
-                const line = d3.line()
-                    .x((d, i) => x(i))
-                    .y(d => y(d));
-
-                svg.append("path")
-                    .datum(data.mean)
-                    .attr("class", "line")
-                    .attr("d", line);
-
-                // Add axes
-                svg.append("g")
-                    .attr("class", "x-axis")
-                    .attr("transform", `translate(0,${{height}})`)
-                    .call(d3.axisBottom(x))
-                    .append("text")
-                    .attr("class", "axis-label")
-                    .attr("x", width/2)
-                    .attr("y", 40)
-                    .text("Time Period");
-
-                svg.append("g")
-                    .attr("class", "y-axis")
-                    .call(d3.axisLeft(y))
-                    .append("text")
-                    .attr("class", "axis-label")
-                    .attr("transform", "rotate(-90)")
-                    .attr("y", -40)
-                    .attr("x", -height/2)
-                    .style("text-anchor", "middle")
-                    .text("Value");
-
-                // Add tooltip for hover
-                const tooltip = d3.select("#forecast-plot")
-                    .append("div")
-                    .attr("class", "tooltip")
-                    .style("opacity", 0);
-
-                // Add hover interaction
-                const bisect = d3.bisector(d => d).left;
-                
-                svg.append("rect")
-                    .attr("class", "overlay")
-                    .attr("width", width)
-                    .attr("height", height)
-                    .style("fill", "none")
-                    .style("pointer-events", "all")
-                    .on("mousemove", function(event) {{
-                        const x0 = x.invert(d3.pointer(event)[0]);
-                        const i = Math.round(x0);
-                        if (i >= 0 && i < data.time.length) {{
-                            tooltip.transition()
-                                .duration(200)
-                                .style("opacity", .9);
-                            tooltip.html(
-                                `Time: ${{data.time[i]}}<br/>` +
-                                `Mean: ${{data.mean[i].toFixed(2)}}<br/>` +
-                                `Range: [${{data.lower[i].toFixed(2)}}, ${{data.upper[i].toFixed(2)}}]`
-                            )
-                            .style("left", (event.pageX + 5) + "px")
-                            .style("top", (event.pageY - 28) + "px");
-                        }}
-                    }})
-                    .on("mouseout", function() {{
-                        tooltip.transition()
-                            .duration(500)
-                            .style("opacity", 0);
-                    }});
-            }})();
-            </script>
-            """
-
-        return "Unsupported visualization type"