Module plugin

Expand description

Plugin System Module

This module provides a comprehensive plugin architecture for the SKLears framework, enabling dynamic loading, validation, and management of machine learning algorithms and data processing components.

§Plugin System Architecture

The plugin system is organized into several key components:

§Core Components

Core Traits: Foundation traits that all plugins must implement
Types & Configuration: Type-safe parameter handling and plugin metadata
Registry: Thread-safe plugin registration and discovery
Loader: Dynamic library loading with cross-platform support

§Advanced Features

Factory & Builder: Factory patterns for plugin creation
Validation: Comprehensive security and quality validation
Security: Permission management and digital signatures
Discovery & Marketplace: Remote plugin discovery and community features
Testing Utilities: Complete testing framework for plugin development

§Quick Start

§Creating a Simple Plugin

use sklears_core::plugin::{Plugin, PluginMetadata, PluginConfig, PluginCategory};
use sklears_core::error::Result;
use std::any::{Any, TypeId};

#[derive(Debug)]
struct MyAlgorithm {
    name: String,
}

impl Plugin for MyAlgorithm {
    fn id(&self) -> &str {
        &self.name
    }

    fn metadata(&self) -> PluginMetadata {
        PluginMetadata {
            name: "My Algorithm".to_string(),
            version: "1.0.0".to_string(),
            description: "An example machine learning algorithm".to_string(),
            author: "Your Name".to_string(),
            category: PluginCategory::Algorithm,
            supported_types: vec![TypeId::of::<f64>()],
            ..Default::default()
        }
    }

    fn initialize(&mut self, _config: &PluginConfig) -> Result<()> {
        println!("Initializing {}", self.name);
        Ok(())
    }

    fn is_compatible(&self, input_type: TypeId) -> bool {
        input_type == TypeId::of::<f64>()
    }

    fn as_any(&self) -> &dyn Any { self }
    fn as_any_mut(&mut self) -> &mut dyn Any { self }
    fn validate_config(&self, _config: &PluginConfig) -> Result<()> { Ok(()) }
    fn cleanup(&mut self) -> Result<()> { Ok(()) }
}

§Using the Plugin Registry

use sklears_core::plugin::{PluginRegistry, Plugin};

fn example() -> Result<(), Box<dyn std::error::Error>> {
    let registry = PluginRegistry::new();

    // Register a plugin
    let plugin = MyAlgorithm { name: "my_algo".to_string() };
    registry.register("my_algo", Box::new(plugin))?;

    // List available plugins
    let plugins = registry.list_plugins()?;
    println!("Available plugins: {:?}", plugins);

    // Search for plugins
    let matches = registry.search_plugins("algorithm")?;
    println!("Found {} matching plugins", matches.len());

    Ok(())
}

§Building Plugin Configurations

use sklears_core::plugin::{PluginConfigBuilder, PluginParameter, LogLevel};

let config = PluginConfigBuilder::new()
    .with_parameter("learning_rate", PluginParameter::Float(0.01))
    .with_parameter("max_iterations", PluginParameter::Int(1000))
    .with_parameter("use_bias", PluginParameter::Bool(true))
    .with_threads(4)
    .with_memory_limit(1024 * 1024 * 1024) // 1GB
    .with_gpu(true)
    .with_log_level(LogLevel::Info)
    .build();

§Dynamic Library Loading

use sklears_core::plugin::{PluginLoader, PluginRegistry};
use std::sync::Arc;

fn example() -> Result<(), Box<dyn std::error::Error>> {
    let registry = Arc::new(PluginRegistry::new());
    let mut loader = PluginLoader::new(registry.clone());

    // Load a single plugin
    loader.load_from_library("./plugins/my_plugin.so", "my_plugin")?;

    // Load all plugins from a directory
    let loaded = loader.load_from_directory("./plugins/")?;
    println!("Loaded {} plugins", loaded.len());

    Ok(())
}

§Plugin Validation and Security

use sklears_core::plugin::{PluginValidator, SecurityPolicy, Permission};

// Create a validator with custom security policy
let mut validator = PluginValidator::new();
let mut policy = SecurityPolicy::standard();
policy.add_dangerous_permission("network_access".to_string());

// Validate plugins before loading
let validation_report = validator.validate_comprehensive(&plugin, &manifest)?;
if validation_report.has_errors() {
    println!("Plugin validation failed: {:?}", validation_report.errors);
}

§Plugin Discovery and Marketplace

use sklears_core::plugin::{PluginDiscoveryService, PluginMarketplace, SearchQuery, PluginCategory};

async fn example() -> Result<(), Box<dyn std::error::Error>> {
    let marketplace = PluginMarketplace::new();

    // Get featured plugins
    let featured = marketplace.get_featured_plugins().await?;
    println!("Featured plugins: {}", featured.len());

    // Search for plugins
    let discovery = PluginDiscoveryService::new();
    let query = SearchQuery {
        text: "classification".to_string(),
        category: Some(PluginCategory::Algorithm),
        capabilities: vec![],
        limit: Some(10),
        min_rating: Some(4.0),
    };
    let results = discovery.search(&query).await?;

    // Install a plugin
    if let Some(result) = results.first() {
        let install_result = discovery.install_plugin(&result.plugin_id, None).await?;
        println!("Installed plugin at: {}", install_result.install_path);
    }

    Ok(())
}

§Testing Plugins

The plugin system includes comprehensive testing utilities:

use sklears_core::plugin::{MockPlugin, ValidationTestRunner, PluginTestFixture};

// Create mock plugins for testing
let mut mock = MockPlugin::new("test_plugin");
mock.set_initialization_error(Some("Test error"));

// Run comprehensive validation tests
let runner = ValidationTestRunner::new();
let fixture = PluginTestFixture::new();
let manifest = &fixture.create_test_manifests()[0];

let report = runner.run_validation_tests(&mock, manifest);
println!("Validation passed: {}", !report.has_errors());

Modules§

core_traits: Core Plugin Traits
discovery_marketplace: Plugin Discovery and Marketplace
factory_builder: Plugin Factory and Configuration Builder
loader: Plugin Loader
marketplace_prelude: Marketplace and discovery imports
prelude: Common plugin development imports
registry: Plugin Registry
security: Plugin Security Framework
security_prelude: Security-focused imports for plugin validation
testing_prelude: Testing utilities imports
testing_utils: Plugin Testing Utilities
types_config: Plugin Types and Configuration
validation: Plugin Validation Framework

Structs§

ApiUsageInfo: API usage information for security analysis
CertificateInfo: Information about a certificate in the trust store
CodeAnalysisInfo: Code analysis information
CompatibilityTestResult: Compatibility test result
CompleteTestResult: Complete test result containing all test outcomes
Dependency: Dependency specification
DigitalSignature: Digital signature for plugin verification
FeaturedPlugin: Featured plugin information
MarketplaceInfo: Marketplace specific metadata
MarketplaceSummary: Marketplace summary statistics
MockPlugin: Mock plugin implementation for testing
PerformanceResult: Performance measurement result
PermissionSet: Permission set for grouping related permissions
PluginConfig: Configuration for plugins
PluginConfigBuilder: Builder for creating plugin configurations
PluginDiscoveryService: Plugin discovery service for remote repositories
PluginInstallResult: Plugin installation result
PluginLoader: Plugin loader for dynamic library loading
PluginManifest: Enhanced plugin manifest with marketplace information
PluginMarketplace: Community plugin marketplace
PluginMetadata: Metadata describing a plugin
PluginPerformanceTester: Performance testing utilities for plugins
PluginRegistry: Registry for managing plugins
PluginRepository: Plugin repository configuration
PluginReview: Plugin review
PluginSearchResult: Plugin search result
PluginStats: Comprehensive plugin statistics
PluginTestFixture: Plugin test fixture for comprehensive testing scenarios
PluginValidator: Advanced plugin validation framework with security analysis
PublicKeyInfo: Information about a public key in the trust store
PublisherInfo: Information about a publisher
RepositoryStats: Repository statistics
RuntimeSettings: Runtime settings for plugin execution
SearchQuery: Search query for plugin discovery
SecurityPolicy: Security policy configuration for the plugin system
TrendingPlugin: Trending plugin information
TrustStore: Trust store for managing trusted keys and certificates
ValidationReport: Validation report containing all validation results
ValidationTestRunner: Validation test runner for comprehensive plugin testing
Vulnerability: Security vulnerability information

Enums§

LogLevel: Logging levels for plugins
Permission: Plugin permission types
PluginCapability: Plugin capabilities
PluginCategory: Plugin categories for organization
PluginParameter: Plugin parameter types
PricingInfo: Plugin pricing information
SubscriptionPeriod: Subscription period
SupportLevel: Support level offered
TrendDirection: Trend direction enumeration
UsageUnit: Usage unit for pricing
ValidationCheck: Types of validation checks
ValidationError: Validation errors that prevent plugin usage
ValidationResult: Validation check results
ValidationWarning: Validation warnings that should be noted but don’t prevent usage

Traits§

AlgorithmPlugin: Trait for algorithm plugins that can fit and predict
ClusteringPlugin: Trait for clustering plugins
Plugin: Core trait that all plugins must implement
PluginFactory: Factory for creating plugin instances
TransformerPlugin: Trait for transformer plugins

Type Aliases§

BoxedPlugin: Type alias for a boxed plugin instance
PluginCreateFn: Type alias for plugin creation function (for dynamic loading)
PluginValidationResult: Type alias for plugin validation result

Module plugin

Module plugin Copy item path

§Plugin System Architecture

§Core Components

§Advanced Features

§Quick Start

§Creating a Simple Plugin

§Using the Plugin Registry

§Building Plugin Configurations

§Dynamic Library Loading

§Plugin Validation and Security

§Plugin Discovery and Marketplace

§Testing Plugins

Modules§

Structs§

Enums§

Traits§

Type Aliases§

Module plugin