burncloud_database_models/
converters.rs1use burncloud_service_models as service;
2use crate::models::*;
3use uuid::Uuid;
4
5impl From<service::Model> for DbModel {
9 fn from(model: service::Model) -> Self {
10 Self {
11 id: model.id,
12 name: model.name,
13 display_name: model.display_name,
14 description: model.description,
15 version: model.version,
16 model_type: serde_json::to_string(&model.model_type).unwrap_or_default(),
17 size_category: serde_json::to_string(&model.size_category).unwrap_or_default(),
18 file_size: model.file_size as i64,
19 provider: model.provider,
20 license: model.license,
21 tags: sqlx::types::Json(model.tags),
22 languages: sqlx::types::Json(model.languages),
23 created_at: model.created_at,
24 updated_at: model.updated_at,
25 file_path: model.file_path,
26 checksum: model.checksum,
27 download_url: model.download_url,
28 config: sqlx::types::Json(model.config),
29 rating: model.rating,
30 download_count: model.download_count as i64,
31 is_official: model.is_official,
32 }
33 }
34}
35
36impl TryFrom<DbModel> for service::Model {
38 type Error = serde_json::Error;
39
40 fn try_from(db_model: DbModel) -> Result<Self, Self::Error> {
41 Ok(Self {
42 id: db_model.id,
43 name: db_model.name,
44 display_name: db_model.display_name,
45 description: db_model.description,
46 version: db_model.version,
47 model_type: serde_json::from_str(&db_model.model_type)?,
48 size_category: serde_json::from_str(&db_model.size_category)?,
49 file_size: db_model.file_size as u64,
50 provider: db_model.provider,
51 license: db_model.license,
52 tags: db_model.tags.0,
53 languages: db_model.languages.0,
54 created_at: db_model.created_at,
55 updated_at: db_model.updated_at,
56 file_path: db_model.file_path,
57 checksum: db_model.checksum,
58 download_url: db_model.download_url,
59 config: db_model.config.0,
60 rating: db_model.rating,
61 download_count: db_model.download_count as u64,
62 is_official: db_model.is_official,
63 })
64 }
65}
66
67pub fn convert_installed_model_to_db(installed: service::InstalledModel) -> (DbModel, DbInstalledModel) {
69 let db_model = DbModel::from(installed.model);
70 let db_installed = DbInstalledModel {
71 id: Uuid::new_v4(),
72 model_id: db_model.id,
73 install_path: installed.install_path,
74 installed_at: installed.installed_at,
75 status: serde_json::to_string(&installed.status).unwrap_or_default(),
76 port: installed.port.map(|p| p as i32),
77 process_id: installed.process_id.map(|p| p as i32),
78 last_used: installed.last_used,
79 usage_count: installed.usage_count as i64,
80 };
81 (db_model, db_installed)
82}
83
84pub fn convert_db_to_installed_model(
85 db_model: DbModel,
86 db_installed: DbInstalledModel,
87) -> Result<service::InstalledModel, serde_json::Error> {
88 let model = service::Model::try_from(db_model)?;
89 Ok(service::InstalledModel {
90 model,
91 install_path: db_installed.install_path,
92 installed_at: db_installed.installed_at,
93 status: serde_json::from_str(&db_installed.status)?,
94 port: db_installed.port.map(|p| p as u16),
95 process_id: db_installed.process_id.map(|p| p as u32),
96 last_used: db_installed.last_used,
97 usage_count: db_installed.usage_count as u64,
98 })
99}
100
101pub fn convert_available_model_to_db(available: service::AvailableModel) -> (DbModel, DbAvailableModel) {
102 let db_model = DbModel::from(available.model);
103 let db_available = DbAvailableModel {
104 id: Uuid::new_v4(),
105 model_id: db_model.id,
106 is_installed: available.is_installed,
107 published_at: available.published_at,
108 last_updated: available.last_updated,
109 system_requirements: sqlx::types::Json(DbSystemRequirements {
110 min_memory_gb: available.system_requirements.min_memory_gb,
111 recommended_memory_gb: available.system_requirements.recommended_memory_gb,
112 min_disk_space_gb: available.system_requirements.min_disk_space_gb,
113 requires_gpu: available.system_requirements.requires_gpu,
114 supported_os: available.system_requirements.supported_os,
115 supported_architectures: available.system_requirements.supported_architectures,
116 }),
117 };
118 (db_model, db_available)
119}
120
121pub fn convert_db_to_available_model(
122 db_model: DbModel,
123 db_available: DbAvailableModel,
124) -> Result<service::AvailableModel, serde_json::Error> {
125 let model = service::Model::try_from(db_model)?;
126 Ok(service::AvailableModel {
127 model,
128 is_installed: db_available.is_installed,
129 published_at: db_available.published_at,
130 last_updated: db_available.last_updated,
131 system_requirements: service::SystemRequirements {
132 min_memory_gb: db_available.system_requirements.0.min_memory_gb,
133 recommended_memory_gb: db_available.system_requirements.0.recommended_memory_gb,
134 min_disk_space_gb: db_available.system_requirements.0.min_disk_space_gb,
135 requires_gpu: db_available.system_requirements.0.requires_gpu,
136 supported_os: db_available.system_requirements.0.supported_os,
137 supported_architectures: db_available.system_requirements.0.supported_architectures,
138 },
139 })
140}
141
142impl From<service::RuntimeConfig> for DbRuntimeConfig {
143 fn from(config: service::RuntimeConfig) -> Self {
144 Self {
145 id: Uuid::new_v4(),
146 name: format!("runtime_config_{}", Uuid::new_v4()),
147 max_context_length: config.max_context_length.map(|c| c as i32),
148 temperature: config.temperature,
149 top_p: config.top_p,
150 top_k: config.top_k.map(|k| k as i32),
151 max_tokens: config.max_tokens.map(|t| t as i32),
152 stop_sequences: sqlx::types::Json(config.stop_sequences),
153 batch_size: config.batch_size.map(|b| b as i32),
154 max_concurrent_requests: config.max_concurrent_requests.map(|r| r as i32),
155 gpu_device_ids: sqlx::types::Json(config.gpu_device_ids.into_iter().map(|id| id as i32).collect()),
156 memory_limit_mb: config.memory_limit_mb.map(|m| m as i64),
157 enable_streaming: config.enable_streaming,
158 custom_params: sqlx::types::Json(config.custom_params),
159 created_at: chrono::Utc::now(),
160 updated_at: chrono::Utc::now(),
161 }
162 }
163}
164
165impl From<DbRuntimeConfig> for service::RuntimeConfig {
166 fn from(db_config: DbRuntimeConfig) -> Self {
167 Self {
168 max_context_length: db_config.max_context_length.map(|c| c as u32),
169 temperature: db_config.temperature,
170 top_p: db_config.top_p,
171 top_k: db_config.top_k.map(|k| k as u32),
172 max_tokens: db_config.max_tokens.map(|t| t as u32),
173 stop_sequences: db_config.stop_sequences.0,
174 batch_size: db_config.batch_size.map(|b| b as u32),
175 max_concurrent_requests: db_config.max_concurrent_requests.map(|r| r as u32),
176 gpu_device_ids: db_config.gpu_device_ids.0.into_iter().map(|id| id as u32).collect(),
177 memory_limit_mb: db_config.memory_limit_mb.map(|m| m as u64),
178 enable_streaming: db_config.enable_streaming,
179 custom_params: db_config.custom_params.0,
180 }
181 }
182}