mseep-rmcp 0.3.3__py3-none-any.whl

rmcp/tools/descriptive.py

@@ -0,0 +1,279 @@
+"""
+Descriptive statistics tools for RMCP.
+
+Comprehensive data exploration and summary capabilities.
+"""
+
+from typing import Dict, Any
+from ..registries.tools import tool
+from ..core.schemas import table_schema
+from ..r_integration import execute_r_script
+
+
+@tool(
+    name="summary_stats",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "variables": {"type": "array", "items": {"type": "string"}},
+            "group_by": {"type": "string"},
+            "percentiles": {"type": "array", "items": {"type": "number"}, "default": [0.25, 0.5, 0.75]}
+        },
+        "required": ["data"]
+    },
+    description="Comprehensive descriptive statistics with optional grouping"
+)
+async def summary_stats(context, params):
+    """Compute comprehensive descriptive statistics."""
+    
+    await context.info("Computing summary statistics")
+    
+    r_script = '''
+    if (!require(dplyr)) install.packages("dplyr", quietly = TRUE)
+    library(dplyr)
+    
+    data <- as.data.frame(args$data)
+    variables <- args$variables
+    group_by <- args$group_by
+    percentiles <- args$percentiles %||% c(0.25, 0.5, 0.75)
+    
+    # Select variables to analyze
+    if (is.null(variables)) {
+        numeric_vars <- names(data)[sapply(data, is.numeric)]
+        if (length(numeric_vars) == 0) {
+            stop("No numeric variables found in data")
+        }
+        variables <- numeric_vars
+    }
+    
+    # Function to compute detailed stats
+    compute_stats <- function(x) {
+        x_clean <- x[!is.na(x)]
+        if (length(x_clean) == 0) {
+            return(list(
+                n = 0, n_missing = length(x), mean = NA, sd = NA, min = NA, max = NA,
+                q25 = NA, median = NA, q75 = NA, skewness = NA, kurtosis = NA
+            ))
+        }
+        
+        stats <- list(
+            n = length(x_clean),
+            n_missing = sum(is.na(x)),
+            mean = mean(x_clean),
+            sd = sd(x_clean),
+            min = min(x_clean),
+            max = max(x_clean),
+            range = max(x_clean) - min(x_clean),
+            skewness = (sum((x_clean - mean(x_clean))^3) / length(x_clean)) / (sd(x_clean)^3),
+            kurtosis = (sum((x_clean - mean(x_clean))^4) / length(x_clean)) / (sd(x_clean)^4) - 3
+        )
+        
+        # Add percentiles
+        for (i in seq_along(percentiles)) {
+            pct_name <- paste0("p", percentiles[i] * 100)
+            stats[[pct_name]] <- quantile(x_clean, percentiles[i])
+        }
+        
+        return(stats)
+    }
+    
+    if (is.null(group_by)) {
+        # Overall statistics
+        stats_list <- list()
+        for (var in variables) {
+            stats_list[[var]] <- compute_stats(data[[var]])
+        }
+        
+        result <- list(
+            statistics = stats_list,
+            variables = variables,
+            n_obs = nrow(data),
+            grouped = FALSE
+        )
+        
+    } else {
+        # Grouped statistics
+        grouped_stats <- list()
+        groups <- unique(data[[group_by]][!is.na(data[[group_by]])])
+        
+        for (group_val in groups) {
+            group_data <- data[data[[group_by]] == group_val, ]
+            group_stats <- list()
+            
+            for (var in variables) {
+                group_stats[[var]] <- compute_stats(group_data[[var]])
+            }
+            
+            grouped_stats[[as.character(group_val)]] <- group_stats
+        }
+        
+        result <- list(
+            statistics = grouped_stats,
+            variables = variables,
+            group_by = group_by,
+            groups = as.character(groups),
+            n_obs = nrow(data),
+            grouped = TRUE
+        )
+    }
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("Summary statistics computed successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("Summary statistics failed", error=str(e))
+        raise
+
+
+@tool(
+    name="outlier_detection",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "variable": {"type": "string"},
+            "method": {"type": "string", "enum": ["iqr", "z_score", "modified_z"], "default": "iqr"},
+            "threshold": {"type": "number", "minimum": 0, "default": 3.0}
+        },
+        "required": ["data", "variable"]
+    },
+    description="Detect outliers using IQR, Z-score, or Modified Z-score methods"
+)
+async def outlier_detection(context, params):
+    """Detect outliers in data."""
+    
+    await context.info("Detecting outliers")
+    
+    r_script = '''
+    data <- as.data.frame(args$data)
+    variable <- args$variable
+    method <- args$method %||% "iqr"
+    threshold <- args$threshold %||% 3.0
+    
+    values <- data[[variable]]
+    values_clean <- values[!is.na(values)]
+    
+    if (method == "iqr") {
+        Q1 <- quantile(values_clean, 0.25)
+        Q3 <- quantile(values_clean, 0.75)
+        IQR <- Q3 - Q1
+        lower_bound <- Q1 - 1.5 * IQR
+        upper_bound <- Q3 + 1.5 * IQR
+        outliers <- which(values < lower_bound | values > upper_bound)
+        
+        bounds <- list(lower = lower_bound, upper = upper_bound, iqr = IQR)
+        
+    } else if (method == "z_score") {
+        mean_val <- mean(values_clean)
+        sd_val <- sd(values_clean)
+        z_scores <- abs((values - mean_val) / sd_val)
+        outliers <- which(z_scores > threshold)
+        
+        bounds <- list(threshold = threshold, mean = mean_val, sd = sd_val)
+        
+    } else if (method == "modified_z") {
+        median_val <- median(values_clean)
+        mad_val <- mad(values_clean)
+        modified_z <- abs(0.6745 * (values - median_val) / mad_val)
+        outliers <- which(modified_z > threshold)
+        
+        bounds <- list(threshold = threshold, median = median_val, mad = mad_val)
+    }
+    
+    result <- list(
+        method = method,
+        outlier_indices = outliers,
+        outlier_values = values[outliers],
+        n_outliers = length(outliers),
+        n_obs = length(values[!is.na(values)]),
+        outlier_percentage = length(outliers) / length(values_clean) * 100,
+        bounds = bounds,
+        variable = variable
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("Outlier detection completed successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("Outlier detection failed", error=str(e))
+        raise
+
+
+@tool(
+    name="frequency_table",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "variables": {"type": "array", "items": {"type": "string"}},
+            "include_percentages": {"type": "boolean", "default": True},
+            "sort_by": {"type": "string", "enum": ["frequency", "value"], "default": "frequency"}
+        },
+        "required": ["data", "variables"]
+    },
+    description="Generate frequency tables with counts and percentages"
+)
+async def frequency_table(context, params):
+    """Generate frequency tables."""
+    
+    await context.info("Creating frequency tables")
+    
+    r_script = '''
+    data <- as.data.frame(args$data)
+    variables <- args$variables
+    include_percentages <- args$include_percentages %||% TRUE
+    sort_by <- args$sort_by %||% "frequency"
+    
+    freq_tables <- list()
+    
+    for (var in variables) {
+        values <- data[[var]]
+        freq_table <- table(values, useNA = "ifany")
+        
+        # Sort if requested
+        if (sort_by == "frequency") {
+            freq_table <- sort(freq_table, decreasing = TRUE)
+        }
+        
+        freq_data <- list(
+            values = names(freq_table),
+            frequencies = as.numeric(freq_table),
+            n_total = length(values[!is.na(values)])
+        )
+        
+        if (include_percentages) {
+            freq_data$percentages <- as.numeric(freq_table) / sum(freq_table) * 100
+        }
+        
+        # Add missing value info
+        n_missing <- sum(is.na(values))
+        if (n_missing > 0) {
+            freq_data$n_missing <- n_missing
+            freq_data$missing_percentage <- n_missing / length(values) * 100
+        }
+        
+        freq_tables[[var]] <- freq_data
+    }
+    
+    result <- list(
+        frequency_tables = freq_tables,
+        variables = variables,
+        total_observations = nrow(data)
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("Frequency tables created successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("Frequency table creation failed", error=str(e))
+        raise

rmcp/tools/econometrics.py

@@ -0,0 +1,250 @@
+"""
+Econometric analysis tools for RMCP.
+
+Advanced econometric modeling for panel data, instrumental variables, etc.
+"""
+
+from typing import Dict, Any
+from ..registries.tools import tool
+from ..core.schemas import table_schema, formula_schema
+from ..r_integration import execute_r_script
+
+
+@tool(
+    name="panel_regression",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "formula": formula_schema(),
+            "id_variable": {"type": "string"},
+            "time_variable": {"type": "string"},
+            "model": {"type": "string", "enum": ["pooling", "within", "between", "random"], "default": "within"},
+            "robust": {"type": "boolean", "default": True}
+        },
+        "required": ["data", "formula", "id_variable", "time_variable"]
+    },
+    description="Panel data regression with fixed/random effects"
+)
+async def panel_regression(context, params):
+    """Perform panel data regression."""
+    
+    await context.info("Fitting panel data regression")
+    
+    r_script = '''
+    if (!require(plm)) install.packages("plm", quietly = TRUE)
+    library(plm)
+    
+    data <- as.data.frame(args$data)
+    formula <- as.formula(args$formula)
+    id_var <- args$id_variable
+    time_var <- args$time_variable
+    model_type <- args$model %||% "within"
+    robust <- args$robust %||% TRUE
+    
+    # Create panel data frame
+    pdata <- pdata.frame(data, index = c(id_var, time_var))
+    
+    # Fit panel model
+    if (model_type == "pooling") {
+        model <- plm(formula, data = pdata, model = "pooling")
+    } else if (model_type == "within") {
+        model <- plm(formula, data = pdata, model = "within")  # Fixed effects
+    } else if (model_type == "between") {
+        model <- plm(formula, data = pdata, model = "between")
+    } else if (model_type == "random") {
+        model <- plm(formula, data = pdata, model = "random")
+    }
+    
+    # Get robust standard errors if requested
+    if (robust) {
+        if (!require(lmtest)) install.packages("lmtest", quietly = TRUE)
+        library(lmtest)
+        robust_se <- coeftest(model, vcov = vcovHC(model, type = "HC1"))
+        coef_table <- robust_se
+    } else {
+        coef_table <- summary(model)$coefficients
+    }
+    
+    result <- list(
+        coefficients = as.list(coef_table[, "Estimate"]),
+        std_errors = as.list(coef_table[, "Std. Error"]), 
+        t_values = as.list(coef_table[, "t value"]),
+        p_values = as.list(coef_table[, "Pr(>|t|)"]),
+        r_squared = summary(model)$r.squared[1],
+        adj_r_squared = summary(model)$r.squared[2],
+        model_type = model_type,
+        robust_se = robust,
+        n_obs = nobs(model),
+        n_groups = pdim(model)$nT$n,
+        time_periods = pdim(model)$nT$T,
+        formula = deparse(formula),
+        id_variable = id_var,
+        time_variable = time_var
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("Panel regression completed successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("Panel regression failed", error=str(e))
+        raise
+
+
+@tool(
+    name="instrumental_variables",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "formula": {"type": "string", "description": "Format: 'y ~ x1 + x2 | z1 + z2' where | separates instruments"},
+            "robust": {"type": "boolean", "default": True}
+        },
+        "required": ["data", "formula"]
+    },
+    description="Two-stage least squares (2SLS) instrumental variables regression"
+)
+async def instrumental_variables(context, params):
+    """Perform instrumental variables regression."""
+    
+    await context.info("Fitting instrumental variables model")
+    
+    r_script = '''
+    if (!require(AER)) install.packages("AER", quietly = TRUE)
+    library(AER)
+    
+    data <- as.data.frame(args$data)
+    formula_str <- args$formula
+    robust <- args$robust %||% TRUE
+    
+    # Parse IV formula (y ~ x1 + x2 | z1 + z2)
+    formula <- as.formula(formula_str)
+    
+    # Fit 2SLS model
+    iv_model <- ivreg(formula, data = data)
+    
+    # Get robust standard errors if requested
+    if (robust) {
+        robust_se <- coeftest(iv_model, vcov = sandwich)
+        coef_table <- robust_se
+    } else {
+        coef_table <- summary(iv_model)$coefficients
+    }
+    
+    # Diagnostic tests
+    summary_iv <- summary(iv_model, diagnostics = TRUE)
+    
+    result <- list(
+        coefficients = as.list(coef_table[, "Estimate"]),
+        std_errors = as.list(coef_table[, "Std. Error"]),
+        t_values = as.list(coef_table[, "t value"]),
+        p_values = as.list(coef_table[, "Pr(>|t|)"]),
+        r_squared = summary_iv$r.squared,
+        adj_r_squared = summary_iv$adj.r.squared,
+        weak_instruments = list(
+            statistic = summary_iv$diagnostics["Weak instruments", "statistic"],
+            p_value = summary_iv$diagnostics["Weak instruments", "p-value"]
+        ),
+        wu_hausman = list(
+            statistic = summary_iv$diagnostics["Wu-Hausman", "statistic"],
+            p_value = summary_iv$diagnostics["Wu-Hausman", "p-value"]
+        ),
+        sargan = list(
+            statistic = summary_iv$diagnostics["Sargan", "statistic"], 
+            p_value = summary_iv$diagnostics["Sargan", "p-value"]
+        ),
+        robust_se = robust,
+        formula = formula_str,
+        n_obs = nobs(iv_model)
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("Instrumental variables model fitted successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("Instrumental variables fitting failed", error=str(e))
+        raise
+
+
+@tool(
+    name="var_model",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "variables": {"type": "array", "items": {"type": "string"}},
+            "lags": {"type": "integer", "minimum": 1, "maximum": 10, "default": 2},
+            "type": {"type": "string", "enum": ["const", "trend", "both", "none"], "default": "const"}
+        },
+        "required": ["data", "variables"]
+    },
+    description="Vector Autoregression (VAR) model for multivariate time series"
+)
+async def var_model(context, params):
+    """Fit Vector Autoregression model."""
+    
+    await context.info("Fitting VAR model")
+    
+    r_script = '''
+    if (!require(vars)) install.packages("vars", quietly = TRUE)
+    library(vars)
+    
+    data <- as.data.frame(args$data)
+    variables <- args$variables
+    lag_order <- args$lags %||% 2
+    var_type <- args$type %||% "const"
+    
+    # Select variables for VAR
+    var_data <- data[, variables, drop = FALSE]
+    
+    # Remove missing values
+    var_data <- na.omit(var_data)
+    
+    # Fit VAR model
+    var_model <- VAR(var_data, p = lag_order, type = var_type)
+    
+    # Extract coefficients for each equation
+    equations <- list()
+    for (var in variables) {
+        eq_summary <- summary(var_model)$varresult[[var]]
+        equations[[var]] <- list(
+            coefficients = as.list(coef(eq_summary)),
+            std_errors = as.list(eq_summary$coefficients[, "Std. Error"]),
+            t_values = as.list(eq_summary$coefficients[, "t value"]),
+            p_values = as.list(eq_summary$coefficients[, "Pr(>|t|)"]),
+            r_squared = eq_summary$r.squared,
+            adj_r_squared = eq_summary$adj.r.squared
+        )
+    }
+    
+    # Model diagnostics
+    var_summary <- summary(var_model)
+    
+    result <- list(
+        equations = equations,
+        variables = variables,
+        lag_order = lag_order,
+        var_type = var_type,
+        n_obs = nobs(var_model),
+        n_variables = length(variables),
+        loglik = logLik(var_model)[1],
+        aic = AIC(var_model),
+        bic = BIC(var_model),
+        residual_covariance = as.matrix(var_summary$covres)
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("VAR model fitted successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("VAR model fitting failed", error=str(e))
+        raise