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());

Re-exports§

pub use core_traits::AlgorithmPlugin;
pub use core_traits::ClusteringPlugin;
pub use core_traits::Plugin;
pub use core_traits::TransformerPlugin;
pub use types_config::LogLevel;
pub use types_config::PluginCapability;
pub use types_config::PluginCategory;
pub use types_config::PluginConfig;
pub use types_config::PluginMetadata;
pub use types_config::PluginParameter;
pub use types_config::RuntimeSettings;
pub use registry::PluginRegistry;
pub use loader::PluginLoader;
pub use factory_builder::PluginConfigBuilder;
pub use factory_builder::PluginFactory;
pub use validation::ApiUsageInfo;
pub use validation::CodeAnalysisInfo;
pub use validation::Dependency;
pub use validation::PluginManifest;
pub use validation::PluginValidator;
pub use validation::ValidationCheck;
pub use validation::ValidationError;
pub use validation::ValidationReport;
pub use validation::ValidationResult;
pub use validation::ValidationWarning;
pub use validation::Vulnerability;
pub use security::CertificateInfo;
pub use security::DigitalSignature;
pub use security::Permission;
pub use security::PermissionSet;
pub use security::PublicKeyInfo;
pub use security::PublisherInfo;
pub use security::SecurityPolicy;
pub use security::TrustStore;
pub use discovery_marketplace::FeaturedPlugin;
pub use discovery_marketplace::MarketplaceInfo;
pub use discovery_marketplace::MarketplaceSummary;
pub use discovery_marketplace::PluginDiscoveryService;
pub use discovery_marketplace::PluginInstallResult;
pub use discovery_marketplace::PluginMarketplace;
pub use discovery_marketplace::PluginRepository;
pub use discovery_marketplace::PluginReview;
pub use discovery_marketplace::PluginSearchResult;
pub use discovery_marketplace::PluginStats;
pub use discovery_marketplace::PricingInfo;
pub use discovery_marketplace::RepositoryStats;
pub use discovery_marketplace::SearchQuery;
pub use discovery_marketplace::SubscriptionPeriod;
pub use discovery_marketplace::SupportLevel;
pub use discovery_marketplace::TrendDirection;
pub use discovery_marketplace::TrendingPlugin;
pub use discovery_marketplace::UsageUnit;
pub use testing_utils::CompatibilityTestResult;
pub use testing_utils::CompleteTestResult;
pub use testing_utils::MockPlugin;
pub use testing_utils::PerformanceResult;
pub use testing_utils::PluginPerformanceTester;
pub use testing_utils::PluginTestFixture;
pub use testing_utils::ValidationTestRunner;

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

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

Re-exports§

Modules§

Type Aliases§

Module plugin