torsh-core 0.1.2

Core types and traits for ToRSh deep learning framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! General error types for ToRSh
//!
//! This module contains miscellaneous error variants including I/O errors,
//! configuration errors, runtime errors, and other general-purpose errors.

use thiserror::Error;

/// General error variants
#[derive(Error, Debug, Clone)]
pub enum GeneralError {
    /// Invalid argument
    #[error("Invalid argument: {0}")]
    InvalidArgument(String),

    /// IO error
    #[error("IO error: {0}")]
    IoError(String),

    /// Configuration error
    #[error("Configuration error: {0}")]
    ConfigError(String),

    /// Runtime error
    #[error("Runtime error: {0}")]
    RuntimeError(String),

    /// Serialization error
    #[error("Serialization error: {0}")]
    SerializationError(String),

    /// Iteration error for iterative algorithms
    #[error("Iteration error: {0}")]
    IterationError(String),

    /// Not implemented error for placeholder functionality
    #[error("Not implemented: {0}")]
    NotImplemented(String),

    /// Invalid operation error
    #[error("Invalid operation: {0}")]
    InvalidOperation(String),

    /// Invalid state error
    #[error("Invalid state: {0}")]
    InvalidState(String),

    /// Other errors
    #[error("{0}")]
    Other(String),

    /// Device mismatch between tensors
    #[error("Device mismatch: tensors must be on the same device")]
    DeviceMismatch,

    /// Unsupported operation for given data type
    #[error("Unsupported operation '{op}' for data type '{dtype}'")]
    UnsupportedOperation { op: String, dtype: String },

    /// Backend-specific error
    #[error("Backend error: {0}")]
    BackendError(String),

    /// Device error
    #[error("Device error: {0}")]
    DeviceError(String),

    /// Memory allocation error
    #[error("Memory allocation failed: {0}")]
    AllocationError(String),

    /// Autograd error
    #[error("Autograd error: {0}")]
    AutogradError(String),

    /// Type mismatch error
    #[error("Type mismatch: expected {expected}, got {actual}")]
    TypeMismatch { expected: String, actual: String },

    /// Dimension error for tensors
    #[error("Dimension error: {0}")]
    DimensionError(String),

    /// Threading error
    #[error("Threading error: {0}")]
    ThreadError(String),

    /// Thread synchronization error (mutex poisoned, channel error, etc.)
    #[error("Thread synchronization error: {0}")]
    SynchronizationError(String),

    /// Numeric conversion error
    #[error("Numeric conversion error: {0}")]
    ConversionError(String),

    /// Data loading error
    #[error("Data loading error: {0}")]
    DataError(String),

    /// Model error
    #[error("Model error: {0}")]
    ModelError(String),

    /// Security error
    #[error("Security error: {0}")]
    SecurityError(String),

    /// Generic error from scirs2
    #[error("SciRS2 error: {0}")]
    SciRS2Error(String),

    /// Compute error
    #[error("Compute error: {0}")]
    ComputeError(String),
}

impl GeneralError {
    pub fn category(&self) -> crate::error::core::ErrorCategory {
        match self {
            Self::IoError(_) => crate::error::core::ErrorCategory::Io,
            Self::ConfigError(_) => crate::error::core::ErrorCategory::Configuration,
            Self::DeviceMismatch | Self::DeviceError(_) | Self::BackendError(_) => {
                crate::error::core::ErrorCategory::Device
            }
            Self::AllocationError(_) => crate::error::core::ErrorCategory::Memory,
            Self::TypeMismatch { .. } | Self::ConversionError(_) => {
                crate::error::core::ErrorCategory::DataType
            }
            Self::ThreadError(_) | Self::SynchronizationError(_) => {
                crate::error::core::ErrorCategory::Threading
            }
            Self::InvalidArgument(_) => crate::error::core::ErrorCategory::UserInput,
            _ => crate::error::core::ErrorCategory::Internal,
        }
    }
}