vidsage-core 0.1.0

Core functionality for VidSage video processing and AI commentary generation
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

//! Core error definitions

use serde::{Deserialize, Serialize};
use thiserror::Error;

/// Core error enumeration
#[derive(Error, Debug, Serialize, Deserialize)]
pub enum CoreError {
    #[error("Video processing error: {0}")]
    VideoProcessingError(String),

    #[error("AI commentary generation error: {0}")]
    CommentaryError(String),

    #[error("Storage error: {0}")]
    StorageError(#[from] crate::storage::StorageError),

    #[error("Configuration error: {0}")]
    ConfigError(#[from] crate::config::ConfigError),

    #[error("Invalid input: {0}")]
    InvalidInput(String),

    #[error("Unauthorized access")]
    Unauthorized,

    #[error("Forbidden access")]
    Forbidden,

    #[error("Resource not found: {0}")]
    NotFound(String),

    #[error("Internal server error: {0}")]
    InternalError(String),

    #[error("Network error: {0}")]
    NetworkError(String),

    #[error("Timeout error")]
    Timeout,

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

    #[error("Deserialization error: {0}")]
    DeserializationError(String),

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

    #[error("JSON serialization error: {0}")]
    JsonError(String),
}

/// Result type for core functionality
pub type Result<T> = std::result::Result<T, CoreError>;

impl CoreError {
    /// Create a new VideoProcessingError
    pub fn video_processing_error(msg: &str) -> Self {
        CoreError::VideoProcessingError(msg.to_string())
    }

    /// Create a new CommentaryError
    pub fn commentary_error(msg: &str) -> Self {
        CoreError::CommentaryError(msg.to_string())
    }

    /// Create a new InvalidInput error
    pub fn invalid_input(msg: &str) -> Self {
        CoreError::InvalidInput(msg.to_string())
    }

    /// Create a new NotFound error
    pub fn not_found(resource: &str) -> Self {
        CoreError::NotFound(resource.to_string())
    }

    /// Create a new InternalError
    pub fn internal_error(msg: &str) -> Self {
        CoreError::InternalError(msg.to_string())
    }

    /// Create a new NetworkError
    pub fn network_error(msg: &str) -> Self {
        CoreError::NetworkError(msg.to_string())
    }

    /// Create a new SerializationError
    pub fn serialization_error(msg: &str) -> Self {
        CoreError::SerializationError(msg.to_string())
    }

    /// Create a new DeserializationError
    pub fn deserialization_error(msg: &str) -> Self {
        CoreError::DeserializationError(msg.to_string())
    }

    /// Create a new IoError
    pub fn io_error(msg: &str) -> Self {
        CoreError::IoError(msg.to_string())
    }

    /// Create a new JsonError
    pub fn json_error(msg: &str) -> Self {
        CoreError::JsonError(msg.to_string())
    }
}