mseep-rmcp 0.3.3__py3-none-any.whl

rmcp/tools/fileops.py

@@ -0,0 +1,315 @@
+"""
+File operations tools for RMCP.
+
+Data import, export, and file manipulation 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="read_csv",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "file_path": {"type": "string"},
+            "header": {"type": "boolean", "default": True},
+            "sep": {"type": "string", "default": ","},
+            "na_strings": {"type": "array", "items": {"type": "string"}, "default": ["", "NA", "NULL"]},
+            "skip_rows": {"type": "integer", "minimum": 0, "default": 0},
+            "max_rows": {"type": "integer", "minimum": 1}
+        },
+        "required": ["file_path"]
+    },
+    description="Read CSV files with flexible parsing options"
+)
+async def read_csv(context, params):
+    """Read CSV file and return data."""
+    
+    await context.info("Reading CSV file", file_path=params.get("file_path"))
+    
+    r_script = '''
+    file_path <- args$file_path
+    header <- args$header %||% TRUE
+    sep <- args$sep %||% ","
+    na_strings <- args$na_strings %||% c("", "NA", "NULL")
+    skip_rows <- args$skip_rows %||% 0
+    max_rows <- args$max_rows
+    
+    # Check if file exists
+    if (!file.exists(file_path)) {
+        stop(paste("File not found:", file_path))
+    }
+    
+    # Read CSV
+    if (!is.null(max_rows)) {
+        data <- read.csv(file_path, header = header, sep = sep, 
+                        na.strings = na_strings, skip = skip_rows, nrows = max_rows)
+    } else {
+        data <- read.csv(file_path, header = header, sep = sep,
+                        na.strings = na_strings, skip = skip_rows)
+    }
+    
+    # Data summary
+    numeric_vars <- names(data)[sapply(data, is.numeric)]
+    character_vars <- names(data)[sapply(data, is.character)]
+    factor_vars <- names(data)[sapply(data, is.factor)]
+    
+    result <- list(
+        data = data,
+        file_info = list(
+            file_path = file_path,
+            n_rows = nrow(data),
+            n_cols = ncol(data),
+            column_names = names(data),
+            numeric_variables = numeric_vars,
+            character_variables = character_vars,
+            factor_variables = factor_vars
+        ),
+        parsing_info = list(
+            header = header,
+            separator = sep,
+            na_strings = na_strings,
+            rows_skipped = skip_rows
+        )
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("CSV file read successfully",
+                          rows=result["file_info"]["n_rows"],
+                          cols=result["file_info"]["n_cols"])
+        return result
+        
+    except Exception as e:
+        await context.error("CSV reading failed", error=str(e))
+        raise
+
+
+@tool(
+    name="write_csv", 
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "file_path": {"type": "string"},
+            "include_rownames": {"type": "boolean", "default": False},
+            "na_string": {"type": "string", "default": ""},
+            "append": {"type": "boolean", "default": False}
+        },
+        "required": ["data", "file_path"]
+    },
+    description="Write data to CSV file with formatting options"
+)
+async def write_csv(context, params):
+    """Write data to CSV file."""
+    
+    await context.info("Writing CSV file", file_path=params.get("file_path"))
+    
+    r_script = '''
+    data <- as.data.frame(args$data)
+    file_path <- args$file_path
+    include_rownames <- args$include_rownames %||% FALSE
+    na_string <- args$na_string %||% ""
+    append_mode <- args$append %||% FALSE
+    
+    # Write CSV
+    write.csv(data, file_path, row.names = include_rownames, na = na_string, append = append_mode)
+    
+    # Verify file was written
+    if (!file.exists(file_path)) {
+        stop(paste("Failed to write file:", file_path))
+    }
+    
+    file_info <- file.info(file_path)
+    
+    result <- list(
+        file_path = file_path,
+        rows_written = nrow(data),
+        cols_written = ncol(data), 
+        file_size_bytes = file_info$size,
+        success = TRUE,
+        timestamp = as.character(Sys.time())
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("CSV file written successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("CSV writing failed", error=str(e))
+        raise
+
+
+@tool(
+    name="data_info",
+    input_schema={
+        "type": "object", 
+        "properties": {
+            "data": table_schema(),
+            "include_sample": {"type": "boolean", "default": True},
+            "sample_size": {"type": "integer", "minimum": 1, "maximum": 100, "default": 5}
+        },
+        "required": ["data"]
+    },
+    description="Get comprehensive information about a dataset"
+)
+async def data_info(context, params):
+    """Get comprehensive dataset information."""
+    
+    await context.info("Analyzing dataset structure")
+    
+    r_script = '''
+    data <- as.data.frame(args$data)
+    include_sample <- args$include_sample %||% TRUE
+    sample_size <- args$sample_size %||% 5
+    
+    # Basic info
+    n_rows <- nrow(data)
+    n_cols <- ncol(data)
+    col_names <- names(data)
+    
+    # Variable types
+    var_types <- sapply(data, class)
+    numeric_vars <- names(data)[sapply(data, is.numeric)]
+    character_vars <- names(data)[sapply(data, is.character)]
+    factor_vars <- names(data)[sapply(data, is.factor)]
+    logical_vars <- names(data)[sapply(data, is.logical)]
+    date_vars <- names(data)[sapply(data, function(x) inherits(x, "Date"))]
+    
+    # Missing value analysis
+    missing_counts <- sapply(data, function(x) sum(is.na(x)))
+    missing_percentages <- missing_counts / n_rows * 100
+    
+    # Memory usage
+    memory_usage <- object.size(data)
+    
+    result <- list(
+        dimensions = list(rows = n_rows, columns = n_cols),
+        variables = list(
+            all = col_names,
+            numeric = numeric_vars,
+            character = character_vars, 
+            factor = factor_vars,
+            logical = logical_vars,
+            date = date_vars
+        ),
+        variable_types = as.list(var_types),
+        missing_values = list(
+            counts = as.list(missing_counts),
+            percentages = as.list(missing_percentages),
+            total_missing = sum(missing_counts),
+            complete_cases = sum(complete.cases(data))
+        ),
+        memory_usage_bytes = as.numeric(memory_usage)
+    )
+    
+    # Add data sample if requested
+    if (include_sample && n_rows > 0) {
+        sample_rows <- min(sample_size, n_rows)
+        result$sample_data <- head(data, sample_rows)
+    }
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("Dataset analysis completed successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("Dataset analysis failed", error=str(e))
+        raise
+
+
+@tool(
+    name="filter_data",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "conditions": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "variable": {"type": "string"},
+                        "operator": {"type": "string", "enum": ["==", "!=", ">", "<", ">=", "<=", "%in%", "!%in%"]},
+                        "value": {}
+                    },
+                    "required": ["variable", "operator", "value"]
+                }
+            },
+            "logic": {"type": "string", "enum": ["AND", "OR"], "default": "AND"}
+        },
+        "required": ["data", "conditions"]
+    },
+    description="Filter data based on multiple conditions"
+)
+async def filter_data(context, params):
+    """Filter data based on conditions."""
+    
+    await context.info("Filtering data")
+    
+    r_script = '''
+    if (!require(dplyr)) install.packages("dplyr", quietly = TRUE)
+    library(dplyr)
+    
+    data <- as.data.frame(args$data)
+    conditions <- args$conditions
+    logic <- args$logic %||% "AND"
+    
+    # Build filter expressions
+    filter_expressions <- c()
+    
+    for (condition in conditions) {
+        var <- condition$variable
+        op <- condition$operator
+        val <- condition$value
+        
+        if (op == "%in%") {
+            expr <- paste0(var, " %in% c(", paste(paste0("'", val, "'"), collapse = ","), ")")
+        } else if (op == "!%in%") {
+            expr <- paste0("!(", var, " %in% c(", paste(paste0("'", val, "'"), collapse = ","), "))")
+        } else if (is.character(val)) {
+            expr <- paste0(var, " ", op, " '", val, "'")
+        } else {
+            expr <- paste0(var, " ", op, " ", val)
+        }
+        
+        filter_expressions <- c(filter_expressions, expr)
+    }
+    
+    # Combine expressions
+    if (logic == "AND") {
+        full_expression <- paste(filter_expressions, collapse = " & ")
+    } else {
+        full_expression <- paste(filter_expressions, collapse = " | ")
+    }
+    
+    # Apply filter
+    filtered_data <- data %>% filter(eval(parse(text = full_expression)))
+    
+    result <- list(
+        data = filtered_data,
+        filter_expression = full_expression,
+        original_rows = nrow(data),
+        filtered_rows = nrow(filtered_data),
+        rows_removed = nrow(data) - nrow(filtered_data),
+        removal_percentage = (nrow(data) - nrow(filtered_data)) / nrow(data) * 100
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("Data filtered successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("Data filtering failed", error=str(e))
+        raise

rmcp/tools/machine_learning.py

@@ -0,0 +1,299 @@
+"""
+Machine learning tools for RMCP.
+
+Clustering, classification trees, and ML capabilities.
+"""
+
+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="kmeans_clustering",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "variables": {"type": "array", "items": {"type": "string"}},
+            "k": {"type": "integer", "minimum": 2, "maximum": 20},
+            "max_iter": {"type": "integer", "minimum": 1, "default": 100},
+            "nstart": {"type": "integer", "minimum": 1, "default": 25}
+        },
+        "required": ["data", "variables", "k"]
+    },
+    description="K-means clustering analysis with cluster validation"
+)
+async def kmeans_clustering(context, params):
+    """Perform K-means clustering."""
+    
+    await context.info("Performing K-means clustering")
+    
+    r_script = '''
+    data <- as.data.frame(args$data)
+    variables <- args$variables
+    k <- args$k
+    max_iter <- args$max_iter %||% 100
+    nstart <- args$nstart %||% 25
+    
+    # Select and prepare data
+    cluster_data <- data[, variables, drop = FALSE]
+    cluster_data <- na.omit(cluster_data)
+    
+    # Scale variables for clustering
+    scaled_data <- scale(cluster_data)
+    
+    # Perform k-means
+    set.seed(123)  # For reproducibility
+    kmeans_result <- kmeans(scaled_data, centers = k, iter.max = max_iter, nstart = nstart)
+    
+    # Calculate cluster statistics
+    cluster_centers <- kmeans_result$centers
+    cluster_assignments <- kmeans_result$cluster
+    
+    # Within-cluster sum of squares
+    wss <- kmeans_result$withinss
+    total_wss <- kmeans_result$tot.withinss
+    between_ss <- kmeans_result$betweenss
+    total_ss <- kmeans_result$totss
+    
+    # Cluster sizes
+    cluster_sizes <- table(cluster_assignments)
+    
+    # Silhouette analysis (if package available)
+    silhouette_score <- NA
+    if (require(cluster, quietly = TRUE)) {
+        library(cluster)
+        sil <- silhouette(cluster_assignments, dist(scaled_data))
+        silhouette_score <- mean(sil[, 3])
+    }
+    
+    result <- list(
+        cluster_assignments = cluster_assignments,
+        cluster_centers = as.data.frame(cluster_centers),
+        cluster_sizes = as.list(cluster_sizes),
+        within_ss = wss,
+        total_within_ss = total_wss,
+        between_ss = between_ss,
+        total_ss = total_ss,
+        variance_explained = between_ss / total_ss * 100,
+        silhouette_score = silhouette_score,
+        k = k,
+        variables = variables,
+        n_obs = nrow(cluster_data),
+        converged = kmeans_result$iter < max_iter
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("K-means clustering completed successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("K-means clustering failed", error=str(e))
+        raise
+
+
+@tool(
+    name="decision_tree",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "formula": formula_schema(),
+            "type": {"type": "string", "enum": ["classification", "regression"], "default": "classification"},
+            "min_split": {"type": "integer", "minimum": 1, "default": 20},
+            "max_depth": {"type": "integer", "minimum": 1, "default": 30}
+        },
+        "required": ["data", "formula"]
+    },
+    description="Decision tree classification and regression"
+)
+async def decision_tree(context, params):
+    """Build decision tree model."""
+    
+    await context.info("Building decision tree")
+    
+    r_script = '''
+    if (!require(rpart)) install.packages("rpart", quietly = TRUE)
+    library(rpart)
+    
+    data <- as.data.frame(args$data)
+    formula <- as.formula(args$formula)
+    tree_type <- args$type %||% "classification"
+    min_split <- args$min_split %||% 20
+    max_depth <- args$max_depth %||% 30
+    
+    # Set method based on type
+    if (tree_type == "classification") {
+        method <- "class"
+    } else {
+        method <- "anova"
+    }
+    
+    # Build tree
+    tree_model <- rpart(formula, data = data, method = method,
+                       control = rpart.control(minsplit = min_split, maxdepth = max_depth))
+    
+    # Get predictions
+    predictions <- predict(tree_model, type = if (method == "class") "class" else "vector")
+    
+    # Calculate performance metrics
+    if (tree_type == "classification") {
+        # Classification metrics
+        response_var <- all.vars(formula)[1]
+        actual <- data[[response_var]]
+        confusion_matrix <- table(Predicted = predictions, Actual = actual)
+        accuracy <- sum(diag(confusion_matrix)) / sum(confusion_matrix)
+        
+        performance <- list(
+            accuracy = accuracy,
+            confusion_matrix = as.matrix(confusion_matrix)
+        )
+    } else {
+        # Regression metrics
+        response_var <- all.vars(formula)[1]
+        actual <- data[[response_var]]
+        mse <- mean((predictions - actual)^2, na.rm = TRUE)
+        rmse <- sqrt(mse)
+        r_squared <- 1 - sum((actual - predictions)^2, na.rm = TRUE) / sum((actual - mean(actual, na.rm = TRUE))^2, na.rm = TRUE)
+        
+        performance <- list(
+            mse = mse,
+            rmse = rmse,
+            r_squared = r_squared
+        )
+    }
+    
+    # Variable importance
+    var_importance <- tree_model$variable.importance
+    
+    result <- list(
+        tree_type = tree_type,
+        performance = performance,
+        variable_importance = as.list(var_importance),
+        predictions = as.numeric(predictions),
+        n_nodes = nrow(tree_model$frame),
+        n_obs = nrow(data),
+        formula = deparse(formula),
+        tree_complexity = tree_model$cptable[nrow(tree_model$cptable), "CP"]
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("Decision tree built successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("Decision tree building failed", error=str(e))
+        raise
+
+
+@tool(
+    name="random_forest",
+    input_schema={
+        "type": "object",
+        "properties": {
+            "data": table_schema(),
+            "formula": formula_schema(),
+            "n_trees": {"type": "integer", "minimum": 1, "maximum": 1000, "default": 500},
+            "mtry": {"type": "integer", "minimum": 1},
+            "importance": {"type": "boolean", "default": True}
+        },
+        "required": ["data", "formula"]
+    },
+    description="Random Forest ensemble model for classification and regression"
+)
+async def random_forest(context, params):
+    """Build Random Forest model."""
+    
+    await context.info("Building Random Forest model")
+    
+    r_script = '''
+    if (!require(randomForest)) install.packages("randomForest", quietly = TRUE)
+    library(randomForest)
+    
+    data <- as.data.frame(args$data)
+    formula <- as.formula(args$formula)
+    n_trees <- args$n_trees %||% 500
+    mtry_val <- args$mtry
+    importance <- args$importance %||% TRUE
+    
+    # Determine problem type
+    response_var <- all.vars(formula)[1]
+    if (is.factor(data[[response_var]]) || is.character(data[[response_var]])) {
+        # Convert to factor if character
+        if (is.character(data[[response_var]])) {
+            data[[response_var]] <- as.factor(data[[response_var]])
+        }
+        problem_type <- "classification"
+    } else {
+        problem_type <- "regression"
+    }
+    
+    # Set default mtry if not provided
+    if (is.null(mtry_val)) {
+        n_predictors <- length(all.vars(formula)[-1])
+        if (problem_type == "classification") {
+            mtry_val <- floor(sqrt(n_predictors))
+        } else {
+            mtry_val <- floor(n_predictors / 3)
+        }
+    }
+    
+    # Build Random Forest
+    rf_model <- randomForest(formula, data = data, ntree = n_trees, 
+                            mtry = mtry_val, importance = importance)
+    
+    # Extract results
+    if (problem_type == "classification") {
+        confusion_matrix <- rf_model$confusion[, -ncol(rf_model$confusion)]  # Remove class.error column
+        oob_error <- rf_model$err.rate[n_trees, "OOB"]
+        
+        performance <- list(
+            oob_error_rate = oob_error,
+            confusion_matrix = as.matrix(confusion_matrix),
+            class_error = as.list(rf_model$confusion[, "class.error"])
+        )
+    } else {
+        mse <- rf_model$mse[n_trees]
+        variance_explained <- (1 - mse / var(data[[response_var]], na.rm = TRUE)) * 100
+        
+        performance <- list(
+            mse = mse,
+            rmse = sqrt(mse),
+            variance_explained = variance_explained
+        )
+    }
+    
+    # Variable importance
+    if (importance) {
+        var_imp <- importance(rf_model)
+        var_importance <- as.data.frame(var_imp)
+    } else {
+        var_importance <- NULL
+    }
+    
+    result <- list(
+        problem_type = problem_type,
+        performance = performance,
+        variable_importance = var_importance,
+        n_trees = n_trees,
+        mtry = rf_model$mtry,
+        oob_error = rf_model$err.rate[n_trees, 1],
+        formula = deparse(formula),
+        n_obs = nrow(data)
+    )
+    '''
+    
+    try:
+        result = execute_r_script(r_script, params)
+        await context.info("Random Forest model built successfully")
+        return result
+        
+    except Exception as e:
+        await context.error("Random Forest building failed", error=str(e))
+        raise