quantrs2_device/provider_capability_discovery/
config.rs

1//! Configuration types for provider capability discovery.
2//!
3//! This module contains all configuration structs and enums for the
4//! provider capability discovery system.
5
6use std::collections::{HashMap, HashSet};
7use std::time::Duration;
8
9use serde::{Deserialize, Serialize};
10
11use super::types::{ProviderFeature, TopologyType};
12
13/// Configuration for capability discovery system
14#[derive(Debug, Clone, Serialize, Deserialize)]
15pub struct DiscoveryConfig {
16    /// Enable automatic discovery
17    pub enable_auto_discovery: bool,
18    /// Discovery interval in seconds
19    pub discovery_interval: u64,
20    /// Enable capability caching
21    pub enable_caching: bool,
22    /// Cache expiration time
23    pub cache_expiration: Duration,
24    /// Enable real-time monitoring
25    pub enable_monitoring: bool,
26    /// Enable analytics
27    pub enable_analytics: bool,
28    /// Discovery strategies
29    pub discovery_strategies: Vec<DiscoveryStrategy>,
30    /// Capability verification settings
31    pub verification_config: VerificationConfig,
32    /// Provider filtering settings
33    pub filtering_config: FilteringConfig,
34    /// Analytics configuration
35    pub analytics_config: CapabilityAnalyticsConfig,
36    /// Monitoring configuration
37    pub monitoring_config: CapabilityMonitoringConfig,
38    /// Comparison configuration
39    pub comparison_config: ComparisonConfig,
40}
41
42/// Discovery strategies for finding providers
43#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
44pub enum DiscoveryStrategy {
45    /// API-based discovery
46    APIDiscovery,
47    /// Registry-based discovery
48    RegistryDiscovery,
49    /// Network-based discovery
50    NetworkDiscovery,
51    /// Configuration-based discovery
52    ConfigurationDiscovery,
53    /// Machine learning-enhanced discovery
54    MLEnhancedDiscovery,
55    /// Hybrid multi-strategy discovery
56    HybridDiscovery,
57}
58
59/// Verification configuration
60#[derive(Debug, Clone, Serialize, Deserialize)]
61pub struct VerificationConfig {
62    /// Enable capability verification
63    pub enable_verification: bool,
64    /// Verification timeout
65    pub verification_timeout: Duration,
66    /// Verification strategies
67    pub verification_strategies: Vec<VerificationStrategy>,
68    /// Required verification confidence
69    pub min_verification_confidence: f64,
70    /// Enable continuous verification
71    pub enable_continuous_verification: bool,
72    /// Verification frequency
73    pub verification_frequency: Duration,
74}
75
76/// Verification strategies
77#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
78pub enum VerificationStrategy {
79    /// API endpoint testing
80    EndpointTesting,
81    /// Capability probing
82    CapabilityProbing,
83    /// Benchmark testing
84    BenchmarkTesting,
85    /// Historical analysis
86    HistoricalAnalysis,
87    /// Community validation
88    CommunityValidation,
89}
90
91/// Provider filtering configuration
92#[derive(Debug, Clone, Serialize, Deserialize)]
93pub struct FilteringConfig {
94    /// Enable provider filtering
95    pub enable_filtering: bool,
96    /// Minimum capability requirements
97    pub min_requirements: CapabilityRequirements,
98    /// Excluded providers
99    pub excluded_providers: HashSet<String>,
100    /// Preferred providers
101    pub preferred_providers: Vec<String>,
102    /// Quality thresholds
103    pub quality_thresholds: QualityThresholds,
104    /// Geographic restrictions
105    pub geographic_restrictions: Option<GeographicRestrictions>,
106}
107
108/// Capability requirements for filtering
109#[derive(Debug, Clone, Serialize, Deserialize)]
110pub struct CapabilityRequirements {
111    /// Minimum number of qubits
112    pub min_qubits: Option<usize>,
113    /// Maximum error rate
114    pub max_error_rate: Option<f64>,
115    /// Required gate types
116    pub required_gates: HashSet<String>,
117    /// Required connectivity
118    pub required_connectivity: Option<ConnectivityRequirement>,
119    /// Required features
120    pub required_features: HashSet<ProviderFeature>,
121    /// Performance requirements
122    pub performance_requirements: PerformanceRequirements,
123}
124
125/// Connectivity requirements
126#[derive(Debug, Clone, Serialize, Deserialize)]
127pub enum ConnectivityRequirement {
128    /// Full connectivity required
129    FullyConnected,
130    /// Minimum connectivity degree
131    MinimumDegree(usize),
132    /// Specific topology required
133    SpecificTopology(TopologyType),
134    /// Custom connectivity pattern
135    CustomPattern(Vec<(usize, usize)>),
136}
137
138/// Performance requirements
139#[derive(Debug, Clone, Serialize, Deserialize)]
140pub struct PerformanceRequirements {
141    /// Maximum execution time
142    pub max_execution_time: Option<Duration>,
143    /// Minimum throughput (circuits/hour)
144    pub min_throughput: Option<f64>,
145    /// Maximum queue time
146    pub max_queue_time: Option<Duration>,
147    /// Minimum availability
148    pub min_availability: Option<f64>,
149    /// Maximum cost per shot
150    pub max_cost_per_shot: Option<f64>,
151}
152
153/// Quality thresholds for filtering
154#[derive(Debug, Clone, Serialize, Deserialize)]
155pub struct QualityThresholds {
156    /// Minimum fidelity
157    pub min_fidelity: f64,
158    /// Maximum error rate
159    pub max_error_rate: f64,
160    /// Minimum uptime
161    pub min_uptime: f64,
162    /// Minimum reliability score
163    pub min_reliability: f64,
164    /// Minimum performance score
165    pub min_performance: f64,
166}
167
168/// Geographic restrictions
169#[derive(Debug, Clone, Serialize, Deserialize)]
170pub struct GeographicRestrictions {
171    /// Allowed regions
172    pub allowed_regions: HashSet<String>,
173    /// Blocked regions
174    pub blocked_regions: HashSet<String>,
175    /// Data sovereignty requirements
176    pub data_sovereignty: bool,
177    /// Compliance requirements
178    pub compliance_requirements: Vec<ComplianceStandard>,
179}
180
181/// Compliance standards
182#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
183pub enum ComplianceStandard {
184    GDPR,
185    HIPAA,
186    SOC2,
187    ISO27001,
188    FedRAMP,
189    Custom(String),
190}
191
192/// Analytics configuration for capabilities
193#[derive(Debug, Clone, Serialize, Deserialize)]
194pub struct CapabilityAnalyticsConfig {
195    /// Enable trend analysis
196    pub enable_trend_analysis: bool,
197    /// Enable predictive analytics
198    pub enable_predictive_analytics: bool,
199    /// Enable comparative analysis
200    pub enable_comparative_analysis: bool,
201    /// Analysis depth
202    pub analysis_depth: AnalysisDepth,
203    /// Historical data retention
204    pub retention_period: Duration,
205    /// Statistical confidence level
206    pub confidence_level: f64,
207}
208
209/// Analysis depth levels
210#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
211pub enum AnalysisDepth {
212    Basic,
213    Standard,
214    Advanced,
215    Comprehensive,
216}
217
218/// Monitoring configuration for capabilities
219#[derive(Debug, Clone, Serialize, Deserialize)]
220pub struct CapabilityMonitoringConfig {
221    /// Enable real-time monitoring
222    pub enable_realtime_monitoring: bool,
223    /// Monitoring frequency
224    pub monitoring_frequency: Duration,
225    /// Health check interval
226    pub health_check_interval: Duration,
227    /// Alert thresholds
228    pub alert_thresholds: HashMap<String, f64>,
229    /// Enable anomaly detection
230    pub enable_anomaly_detection: bool,
231    /// Anomaly sensitivity
232    pub anomaly_sensitivity: f64,
233}
234
235/// Comparison configuration
236#[derive(Debug, Clone, Serialize, Deserialize)]
237pub struct ComparisonConfig {
238    /// Enable automatic comparison
239    pub enable_auto_comparison: bool,
240    /// Comparison criteria
241    pub comparison_criteria: Vec<ComparisonCriterion>,
242    /// Ranking algorithms
243    pub ranking_algorithms: Vec<RankingAlgorithm>,
244    /// Weight distribution
245    pub criterion_weights: HashMap<String, f64>,
246    /// Enable multi-dimensional analysis
247    pub enable_multidimensional_analysis: bool,
248}
249
250/// Comparison criteria
251#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
252pub enum ComparisonCriterion {
253    Performance,
254    Cost,
255    Reliability,
256    Availability,
257    Features,
258    Security,
259    Compliance,
260    Support,
261    Innovation,
262    Custom(String),
263}
264
265/// Ranking algorithms
266#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
267pub enum RankingAlgorithm {
268    WeightedSum,
269    TOPSIS,
270    AHP, // Analytic Hierarchy Process
271    ELECTRE,
272    PROMETHEE,
273    MachineLearning,
274    Custom(String),
275}
276
277impl Default for DiscoveryConfig {
278    fn default() -> Self {
279        Self {
280            enable_auto_discovery: true,
281            discovery_interval: 3600, // 1 hour
282            enable_caching: true,
283            cache_expiration: Duration::from_secs(86400), // 24 hours
284            enable_monitoring: true,
285            enable_analytics: true,
286            discovery_strategies: vec![
287                DiscoveryStrategy::APIDiscovery,
288                DiscoveryStrategy::RegistryDiscovery,
289            ],
290            verification_config: VerificationConfig {
291                enable_verification: true,
292                verification_timeout: Duration::from_secs(300),
293                verification_strategies: vec![
294                    VerificationStrategy::EndpointTesting,
295                    VerificationStrategy::CapabilityProbing,
296                ],
297                min_verification_confidence: 0.8,
298                enable_continuous_verification: true,
299                verification_frequency: Duration::from_secs(86400),
300            },
301            filtering_config: FilteringConfig {
302                enable_filtering: true,
303                min_requirements: CapabilityRequirements {
304                    min_qubits: Some(2),
305                    max_error_rate: Some(0.1),
306                    required_gates: HashSet::new(),
307                    required_connectivity: None,
308                    required_features: HashSet::new(),
309                    performance_requirements: PerformanceRequirements {
310                        max_execution_time: None,
311                        min_throughput: None,
312                        max_queue_time: None,
313                        min_availability: Some(0.9),
314                        max_cost_per_shot: None,
315                    },
316                },
317                excluded_providers: HashSet::new(),
318                preferred_providers: Vec::new(),
319                quality_thresholds: QualityThresholds {
320                    min_fidelity: 0.8,
321                    max_error_rate: 0.1,
322                    min_uptime: 0.95,
323                    min_reliability: 0.9,
324                    min_performance: 0.7,
325                },
326                geographic_restrictions: None,
327            },
328            analytics_config: CapabilityAnalyticsConfig {
329                enable_trend_analysis: true,
330                enable_predictive_analytics: true,
331                enable_comparative_analysis: true,
332                analysis_depth: AnalysisDepth::Standard,
333                retention_period: Duration::from_secs(30 * 86400), // 30 days
334                confidence_level: 0.95,
335            },
336            monitoring_config: CapabilityMonitoringConfig {
337                enable_realtime_monitoring: true,
338                monitoring_frequency: Duration::from_secs(300), // 5 minutes
339                health_check_interval: Duration::from_secs(600), // 10 minutes
340                alert_thresholds: HashMap::new(),
341                enable_anomaly_detection: true,
342                anomaly_sensitivity: 0.8,
343            },
344            comparison_config: ComparisonConfig {
345                enable_auto_comparison: true,
346                comparison_criteria: vec![
347                    ComparisonCriterion::Performance,
348                    ComparisonCriterion::Cost,
349                    ComparisonCriterion::Reliability,
350                ],
351                ranking_algorithms: vec![RankingAlgorithm::WeightedSum],
352                criterion_weights: HashMap::new(),
353                enable_multidimensional_analysis: true,
354            },
355        }
356    }
357}
quantrs2_device/provider_capability_discovery/config.rs

quantrs2_device/provider_capability_discovery/
config.rs
