Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Eliminate #[allow(clippy::too_many_arguments)]

Manav Rathiabd1d7eef3b3
diff --git a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs b/rust/apps/ensu/src-tauri/src/commands/chat_db.rs
index fbff917f65..d8fa500da7 100644
--- a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs
+++ b/rust/apps/ensu/src-tauri/src/commands/chat_db.rs
@@ -371,21 +371,19 @@ pub async fn chat_db_insert_message_with_uuid(
state: State<'_, ChatDbState>,
input: ChatMessageUpsertInput,
) -> Result<ChatMessageDto, ApiError> {
- let message_uuid = parse_uuid(&input.message_uuid)?;
- let session_uuid = parse_uuid(&input.session_uuid)?;
- let parent = optional_uuid(&input.parent_message_uuid)?;
- let sender = normalize_sender(&input.sender)?;
- let attachments = convert_attachments(input.attachments)?;
+ let message = db::Message {
+ uuid: parse_uuid(&input.message_uuid)?,
+ session_uuid: parse_uuid(&input.session_uuid)?,
+ parent_message_uuid: optional_uuid(&input.parent_message_uuid)?,
+ sender: normalize_sender(&input.sender)?
+ .parse()
+ .map_err(ApiError::from)?,
+ text: input.text,
+ attachments: convert_attachments(input.attachments)?,
+ created_at: input.created_at,
+ };
with_chat_db_async(&state, move |db| {
- Ok(ChatMessageDto::from(db.insert_message_with_uuid(
- message_uuid,
- session_uuid,
- sender,
- &input.text,
- parent,
- attachments,
- input.created_at,
- )?))
+ Ok(ChatMessageDto::from(db.insert_message_with_uuid(&message)?))
})
.await
}
diff --git a/rust/apps/ensu/src-tauri/src/commands/chat_db_migration.rs b/rust/apps/ensu/src-tauri/src/commands/chat_db_migration.rs
index 43d5cb805c..bdf7b74978 100644
--- a/rust/apps/ensu/src-tauri/src/commands/chat_db_migration.rs
+++ b/rust/apps/ensu/src-tauri/src/commands/chat_db_migration.rs
@@ -100,15 +100,7 @@ fn import(
.map_err(ApiError::from)?;
for message in source.get_messages(session.uuid).map_err(ApiError::from)? {
target
- .insert_message_with_uuid(
- message.uuid,
- message.session_uuid,
- message.sender.as_str(),
- &message.text,
- message.parent_message_uuid,
- message.attachments.clone(),
- message.created_at,
- )
+ .insert_message_with_uuid(&message)
.map_err(ApiError::from)?;
for attachment in message.attachments {
let from = source_attachments.join(&attachment.id);
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rs
index 987b59b042..1c4b257a81 100644
--- a/rust/bindings/wasm/space/src/space.rs
+++ b/rust/bindings/wasm/space/src/space.rs
@@ -104,6 +104,15 @@ struct OpenSpaceLinkCtxJsInput {
client_version: Option<String>,
}
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct PostPhotoAssetOptionsJsInput {
+ width: Option<i32>,
+ height: Option<i32>,
+ media_type: Option<String>,
+ thumb_hash: Option<String>,
+}
+
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct CreatedSpaceJs {
@@ -982,18 +991,15 @@ impl SpaceAccountCtxHandle {
}
/// Create a single-photo post with optional caption.
- #[allow(clippy::too_many_arguments)]
#[wasm_bindgen(js_name = createPhotoPost)]
pub async fn create_photo_post(
&self,
space_id: String,
photo_bytes: Vec<u8>,
caption: Option<String>,
- width: Option<i32>,
- height: Option<i32>,
- media_type: Option<String>,
- thumb_hash: Option<String>,
+ photo_options: JsValue,
) -> Result<JsValue, WasmSpaceError> {
+ let photo_options: PostPhotoAssetOptionsJsInput = swb::from_value(photo_options)?;
let post_key = self.inner.generate_post_key();
let object = self
.inner
@@ -1002,10 +1008,10 @@ impl SpaceAccountCtxHandle {
&post_key,
&photo_bytes,
PostPhotoAssetOptions {
- width,
- height,
- media_type,
- thumb_hash,
+ width: photo_options.width,
+ height: photo_options.height,
+ media_type: photo_options.media_type,
+ thumb_hash: photo_options.thumb_hash,
},
)
.await?;
diff --git a/rust/crates/assets/src/download.rs b/rust/crates/assets/src/download.rs
index 1d14cb5196..8dc6c1142e 100644
--- a/rust/crates/assets/src/download.rs
+++ b/rust/crates/assets/src/download.rs
@@ -186,6 +186,19 @@ struct RangePartState {
retry_count: u32,
}
+struct RangeDownloadContext<'a, 'progress> {
+ client: &'a Client,
+ target: &'a DownloadTarget,
+ total: u64,
+ response_metadata: Option<&'a ResponseMetadata>,
+ range_states: &'a Mutex<Vec<RangePartState>>,
+ range_metadata: &'a Mutex<RangeDownloadMetadata>,
+ range_metadata_path: &'a Path,
+ file_started_at: Instant,
+ on_progress: &'a Mutex<&'progress mut (dyn FnMut(FileProgress) + Send)>,
+ is_cancelled: &'a (dyn Fn() -> bool + Sync),
+}
+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct ContentRange {
start: u64,
@@ -700,7 +713,6 @@ async fn download_file_ranged(
.truncate(false)
.open(&tmp_path)?;
file.set_len(total)?;
- let file = Arc::new(file);
let range_states = range_metadata
.ranges
@@ -715,11 +727,23 @@ async fn download_file_ranged(
retry_count: 0,
})
.collect::<Vec<_>>();
- let range_states = Arc::new(Mutex::new(range_states));
- let range_metadata = Arc::new(Mutex::new(range_metadata));
- let on_progress = Arc::new(Mutex::new(on_progress));
+ let range_states = Mutex::new(range_states);
+ let range_metadata = Mutex::new(range_metadata);
+ let on_progress = Mutex::new(on_progress);
+ let range_download = RangeDownloadContext {
+ client,
+ target,
+ total,
+ response_metadata: response_metadata.as_ref(),
+ range_states: &range_states,
+ range_metadata: &range_metadata,
+ range_metadata_path: &range_metadata_path,
+ file_started_at,
+ on_progress: &on_progress,
+ is_cancelled,
+ };
- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);
+ range_download.emit_progress();
let mut downloads = Vec::new();
{
@@ -729,38 +753,13 @@ async fn download_file_ranged(
continue;
}
- let file = Arc::clone(&file);
- let range_states = Arc::clone(&range_states);
- let range_metadata = Arc::clone(&range_metadata);
- let range_metadata_path = range_metadata_path.clone();
- let response_metadata = response_metadata.clone();
- let on_progress = Arc::clone(&on_progress);
-
- downloads.push(async move {
- download_range_part(
- client,
- target,
- file,
- part_index,
- range,
- total,
- response_metadata,
- range_states,
- range_metadata,
- range_metadata_path,
- file_started_at,
- on_progress,
- is_cancelled,
- )
- .await
- });
+ downloads.push(range_download.download_part(&file, part_index, range));
}
}
try_join_all(downloads).await?;
drop(file);
-
- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);
+ range_download.emit_progress();
if let Err(err) = check_sha256(&tmp_path, &target.sha256, &target.label).await {
let _ = fs::remove_file(&tmp_path);
@@ -802,149 +801,184 @@ async fn download_file_ranged(
})
}
-#[allow(clippy::too_many_arguments)]
-async fn download_range_part(
- client: &Client,
- target: &DownloadTarget,
- file: Arc<File>,
- part_index: usize,
- range: RangeDownloadPartMetadata,
- total: u64,
- response_metadata: Option<ResponseMetadata>,
- range_states: Arc<Mutex<Vec<RangePartState>>>,
- range_metadata: Arc<Mutex<RangeDownloadMetadata>>,
- range_metadata_path: PathBuf,
- file_started_at: Instant,
- on_progress: Arc<Mutex<&mut (dyn FnMut(FileProgress) + Send)>>,
- is_cancelled: &(impl Fn() -> bool + Sync),
-) -> Result<(), Error> {
- let range_len = range_download_len(range);
+impl RangeDownloadContext<'_, '_> {
+ async fn download_part(
+ &self,
+ file: &File,
+ part_index: usize,
+ range: RangeDownloadPartMetadata,
+ ) -> Result<(), Error> {
+ let range_len = range_download_len(range);
- for attempt in 1..=MAX_ATTEMPTS {
- if is_cancelled() {
- return Err(Error::Cancelled);
- }
+ for attempt in 1..=MAX_ATTEMPTS {
+ if (self.is_cancelled)() {
+ return Err(Error::Cancelled);
+ }
- {
- let mut states = range_states.lock().expect("range state lock");
- if let Some(state) = states.get_mut(part_index) {
- state.downloaded_bytes = 0;
+ {
+ let mut states = self.range_states.lock().expect("range state lock");
+ if let Some(state) = states.get_mut(part_index) {
+ state.downloaded_bytes = 0;
+ }
}
- }
- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);
+ self.emit_progress();
- let mut response =
- match request_model_range(client, &target.url, range, response_metadata.as_ref()).await
+ let mut response = match request_model_range(
+ self.client,
+ &self.target.url,
+ range,
+ self.response_metadata,
+ )
+ .await
{
Ok(response) => response,
Err(err) => {
if attempt == MAX_ATTEMPTS {
return Err(err);
}
- increment_range_retry(&range_states, part_index);
- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);
+ self.increment_retry(part_index);
+ self.emit_progress();
continue;
}
};
- if response.status() != StatusCode::PARTIAL_CONTENT {
- if response.status() == StatusCode::OK
- || response.status() == StatusCode::RANGE_NOT_SATISFIABLE
- {
- return Err(Error::Http(response.status().as_u16()));
- }
- if attempt == MAX_ATTEMPTS {
- return Err(Error::Http(response.status().as_u16()));
+ if response.status() != StatusCode::PARTIAL_CONTENT {
+ if response.status() == StatusCode::OK
+ || response.status() == StatusCode::RANGE_NOT_SATISFIABLE
+ {
+ return Err(Error::Http(response.status().as_u16()));
+ }
+ if attempt == MAX_ATTEMPTS {
+ return Err(Error::Http(response.status().as_u16()));
+ }
+ self.increment_retry(part_index);
+ self.emit_progress();
+ continue;
}
- increment_range_retry(&range_states, part_index);
- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);
- continue;
- }
- validate_range_response(&response, range, total)?;
+ validate_range_response(&response, range, self.total)?;
- let mut downloaded_in_range = 0u64;
- let mut last_progress = Instant::now();
- let mut retry_attempt = false;
+ let mut downloaded_in_range = 0u64;
+ let mut last_progress = Instant::now();
+ let mut retry_attempt = false;
- loop {
- if is_cancelled() {
- return Err(Error::Cancelled);
- }
+ loop {
+ if (self.is_cancelled)() {
+ return Err(Error::Cancelled);
+ }
- let chunk = match response.chunk().await {
- Ok(chunk) => chunk,
- Err(err) => {
- if attempt == MAX_ATTEMPTS {
- return Err(Error::Network(err.to_string()));
+ let chunk = match response.chunk().await {
+ Ok(chunk) => chunk,
+ Err(err) => {
+ if attempt == MAX_ATTEMPTS {
+ return Err(Error::Network(err.to_string()));
+ }
+ self.increment_retry(part_index);
+ retry_attempt = true;
+ break;
}
- increment_range_retry(&range_states, part_index);
- retry_attempt = true;
+ };
+ let Some(chunk) = chunk else {
break;
+ };
+
+ let chunk_len = chunk.len() as u64;
+ if downloaded_in_range.saturating_add(chunk_len) > range_len {
+ return Err(Error::Protocol(
+ "received more bytes than requested".to_string(),
+ ));
}
- };
- let Some(chunk) = chunk else {
- break;
- };
- let chunk_len = chunk.len() as u64;
- if downloaded_in_range.saturating_add(chunk_len) > range_len {
- return Err(Error::Protocol(
- "received more bytes than requested".to_string(),
- ));
- }
+ write_all_at(file, chunk.as_ref(), range.start + downloaded_in_range)?;
+ downloaded_in_range = downloaded_in_range.saturating_add(chunk_len);
- write_all_at(
- file.as_ref(),
- chunk.as_ref(),
- range.start + downloaded_in_range,
- )?;
- downloaded_in_range = downloaded_in_range.saturating_add(chunk_len);
+ {
+ let mut states = self.range_states.lock().expect("range state lock");
+ if let Some(state) = states.get_mut(part_index) {
+ state.downloaded_bytes = downloaded_in_range;
+ state.network_downloaded_bytes =
+ state.network_downloaded_bytes.saturating_add(chunk_len);
+ }
+ }
- {
- let mut states = range_states.lock().expect("range state lock");
- if let Some(state) = states.get_mut(part_index) {
- state.downloaded_bytes = downloaded_in_range;
- state.network_downloaded_bytes =
- state.network_downloaded_bytes.saturating_add(chunk_len);
+ if last_progress.elapsed() >= PROGRESS_INTERVAL {
+ self.emit_progress();
+ last_progress = Instant::now();
}
}
- if last_progress.elapsed() >= PROGRESS_INTERVAL {
- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);
- last_progress = Instant::now();
+ if retry_attempt {
+ self.emit_progress();
+ continue;
}
- }
- if retry_attempt {
- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);
- continue;
- }
+ if downloaded_in_range != range_len {
+ if attempt == MAX_ATTEMPTS {
+ return Err(Error::SizeMismatch {
+ expected: range_len,
+ actual: downloaded_in_range,
+ });
+ }
+ self.increment_retry(part_index);
+ self.emit_progress();
+ continue;
+ }
- if downloaded_in_range != range_len {
- if attempt == MAX_ATTEMPTS {
- return Err(Error::SizeMismatch {
- expected: range_len,
- actual: downloaded_in_range,
- });
+ {
+ let mut states = self.range_states.lock().expect("range state lock");
+ if let Some(state) = states.get_mut(part_index) {
+ state.downloaded_bytes = range_len;
+ }
}
- increment_range_retry(&range_states, part_index);
- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);
- continue;
+ self.mark_complete(part_index)?;
+ self.emit_progress();
+ return Ok(());
}
- {
- let mut states = range_states.lock().expect("range state lock");
- if let Some(state) = states.get_mut(part_index) {
- state.downloaded_bytes = range_len;
- }
+ unreachable!("the final attempt returns")
+ }
+
+ fn emit_progress(&self) {
+ let states = self.range_states.lock().expect("range state lock");
+ let downloaded_bytes = states
+ .iter()
+ .map(|state| state.downloaded_bytes)
+ .sum::<u64>()
+ .min(self.total);
+ let network_downloaded_bytes = states
+ .iter()
+ .map(|state| state.network_downloaded_bytes)
+ .sum::<u64>();
+ let retry_count = states
+ .iter()
+ .map(|state| state.retry_count)
+ .fold(0u32, u32::saturating_add);
+ drop(states);
+
+ let mut callback = self.on_progress.lock().expect("progress lock");
+ (**callback)(FileProgress {
+ downloaded_bytes,
+ total_bytes: Some(self.total),
+ network_downloaded_bytes,
+ elapsed: self.file_started_at.elapsed(),
+ retry_count,
+ });
+ }
+
+ fn increment_retry(&self, part_index: usize) {
+ let mut states = self.range_states.lock().expect("range state lock");
+ if let Some(state) = states.get_mut(part_index) {
+ state.retry_count = state.retry_count.saturating_add(1);
}
- mark_range_complete(&range_metadata, &range_metadata_path, part_index)?;
- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);
- return Ok(());
}
- unreachable!("the final attempt returns")
+ fn mark_complete(&self, part_index: usize) -> Result<(), Error> {
+ let mut metadata = self.range_metadata.lock().expect("range metadata lock");
+ if let Some(range) = metadata.ranges.get_mut(part_index) {
+ range.complete = true;
+ }
+ write_range_download_metadata(self.range_metadata_path, &metadata)
+ }
}
async fn request_file(
@@ -1130,57 +1164,6 @@ fn range_download_len(range: RangeDownloadPartMetadata) -> u64 {
range.end.saturating_sub(range.start).saturating_add(1)
}
-fn emit_range_file_progress(
- total_bytes: u64,
- file_started_at: Instant,
- range_states: &Arc<Mutex<Vec<RangePartState>>>,
- on_progress: &Arc<Mutex<&mut (dyn FnMut(FileProgress) + Send)>>,
-) {
- let states = range_states.lock().expect("range state lock");
- let downloaded_bytes = states
- .iter()
- .map(|state| state.downloaded_bytes)
- .sum::<u64>()
- .min(total_bytes);
- let network_downloaded_bytes = states
- .iter()
- .map(|state| state.network_downloaded_bytes)
- .sum::<u64>();
- let retry_count = states
- .iter()
- .map(|state| state.retry_count)
- .fold(0u32, u32::saturating_add);
- drop(states);
-
- let mut callback = on_progress.lock().expect("progress lock");
- (**callback)(FileProgress {
- downloaded_bytes,
- total_bytes: Some(total_bytes),
- network_downloaded_bytes,
- elapsed: file_started_at.elapsed(),
- retry_count,
- });
-}
-
-fn increment_range_retry(range_states: &Arc<Mutex<Vec<RangePartState>>>, part_index: usize) {
- let mut states = range_states.lock().expect("range state lock");
- if let Some(state) = states.get_mut(part_index) {
- state.retry_count = state.retry_count.saturating_add(1);
- }
-}
-
-fn mark_range_complete(
- range_metadata: &Arc<Mutex<RangeDownloadMetadata>>,
- range_metadata_path: &Path,
- part_index: usize,
-) -> Result<(), Error> {
- let mut metadata = range_metadata.lock().expect("range metadata lock");
- if let Some(range) = metadata.ranges.get_mut(part_index) {
- range.complete = true;
- }
- write_range_download_metadata(range_metadata_path, &metadata)
-}
-
fn validate_range_response(
response: &Response,
range: RangeDownloadPartMetadata,
diff --git a/rust/crates/ensu/src/db/chat/mod.rs b/rust/crates/ensu/src/db/chat/mod.rs
index 3df9ddee27..a2f1a08cc9 100644
--- a/rust/crates/ensu/src/db/chat/mod.rs
+++ b/rust/crates/ensu/src/db/chat/mod.rs
@@ -209,20 +209,9 @@ impl<B: Backend> ChatDb<B> {
})
}
- #[allow(clippy::too_many_arguments)]
- pub fn insert_message_with_uuid(
- &self,
- uuid: Uuid,
- session_uuid: Uuid,
- sender: &str,
- text: &str,
- parent: Option<Uuid>,
- attachments: Vec<AttachmentMeta>,
- created_at: i64,
- ) -> Result<Message> {
- let sender: Sender = sender.parse()?;
- let encrypted_text = crypto::encrypt_string(text, &self.key)?;
- let attachments_json = self.serialize_attachments(&attachments)?;
+ pub fn insert_message_with_uuid(&self, message: &Message) -> Result<Message> {
+ let encrypted_text = crypto::encrypt_string(&message.text, &self.key)?;
+ let attachments_json = self.serialize_attachments(&message.attachments)?;
self.backend.transaction(|tx| {
let inserted = tx.execute(
@@ -232,24 +221,24 @@ impl<B: Backend> ChatDb<B> {
) VALUES (?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(message_uuid) DO NOTHING",
&[
- Value::Text(uuid.to_string()),
- Value::Text(session_uuid.to_string()),
- optional_uuid(parent),
- Value::Text(sender.as_str().to_string()),
+ Value::Text(message.uuid.to_string()),
+ Value::Text(message.session_uuid.to_string()),
+ optional_uuid(message.parent_message_uuid),
+ Value::Text(message.sender.as_str().to_string()),
Value::Blob(encrypted_text),
attachments_json.map(Value::Text).unwrap_or(Value::Null),
- Value::Integer(created_at),
+ Value::Integer(message.created_at),
],
)?;
if inserted == 1 {
- self.touch_session_at_least(tx, session_uuid, created_at)?;
+ self.touch_session_at_least(tx, message.session_uuid, message.created_at)?;
}
Ok(())
})?;
- self.get_message(uuid)?.ok_or(Error::NotFound {
+ self.get_message(message.uuid)?.ok_or(Error::NotFound {
entity: EntityType::Message,
- id: uuid,
+ id: message.uuid,
})
}
diff --git a/rust/crates/ensu/src/llm/generate.rs b/rust/crates/ensu/src/llm/generate.rs
index 63ebcdafa0..1c07406232 100644
--- a/rust/crates/ensu/src/llm/generate.rs
+++ b/rust/crates/ensu/src/llm/generate.rs
@@ -315,96 +315,102 @@ impl StreamDecoder {
}
}
-#[allow(clippy::too_many_arguments)]
-fn run_generation_loop(
- ctx: &mut LlamaContext,
- sampler: &mut LlamaSampler,
- cancel_flag: &AtomicBool,
- sink: &mut dyn EventSink,
+struct GenerationJob<'a> {
+ cancel_flag: &'a AtomicBool,
+ sink: &'a mut dyn EventSink,
job_id: JobId,
max_tokens: usize,
- stop_sequences: &[String],
- generated_tokens_count: &mut i32,
- mut cached_tokens: Option<&mut Vec<LlamaToken>>,
- mut pos: i32,
- mut logits_index: i32,
-) -> Result<(), Error> {
- let mut decoder = StreamDecoder::new(stop_sequences);
- let mut stop_triggered = false;
- let n_ctx = ctx.n_ctx();
-
- for _ in 0..max_tokens {
- if cancel_flag.load(Ordering::Relaxed) {
- return Err(Error::Cancelled);
- }
- if pos >= n_ctx as i32 {
- break;
- }
-
- let token = sampler.sample(ctx, logits_index);
- sampler.accept(token);
- *generated_tokens_count = generated_tokens_count.saturating_add(1);
+ stop_sequences: &'a [String],
+ prompt_tokens: i32,
+ generated_tokens: i32,
+}
- if ctx.model.is_eog_token(token) {
- break;
- }
+impl GenerationJob<'_> {
+ fn run(
+ &mut self,
+ ctx: &mut LlamaContext,
+ sampler: &mut LlamaSampler,
+ mut cached_tokens: Option<&mut Vec<LlamaToken>>,
+ mut pos: i32,
+ mut logits_index: i32,
+ ) -> Result<(), Error> {
+ let mut decoder = StreamDecoder::new(self.stop_sequences);
+ let mut stop_triggered = false;
+ let n_ctx = ctx.n_ctx();
+
+ for _ in 0..self.max_tokens {
+ if self.cancel_flag.load(Ordering::Relaxed) {
+ return Err(Error::Cancelled);
+ }
+ if pos >= n_ctx as i32 {
+ break;
+ }
- let bytes = token_piece_bytes(ctx.model, token).map_err(|err| Error::Llama {
- op: "Detokenize failed",
- message: err.to_string(),
- })?;
- let step = decoder.push_bytes(&bytes);
-
- if let Some(text) = step.text {
- sink.add(GenerationEvent::Text {
- job_id,
- text,
- token_id: Some(token.0),
- });
- }
+ let token = sampler.sample(ctx, logits_index);
+ sampler.accept(token);
+ self.generated_tokens = self.generated_tokens.saturating_add(1);
- if step.stop {
- stop_triggered = true;
- break;
- }
+ if ctx.model.is_eog_token(token) {
+ break;
+ }
- let mut step_batch = LlamaBatch::new(1, 1);
- step_batch
- .add(token, pos, &[0], true)
- .map_err(|err| Error::Llama {
- op: "Failed to add token",
+ let bytes = token_piece_bytes(ctx.model, token).map_err(|err| Error::Llama {
+ op: "Detokenize failed",
message: err.to_string(),
})?;
- if let Err(err) = ctx.decode(&mut step_batch) {
- ctx.clear_kv_cache();
+ let step = decoder.push_bytes(&bytes);
+
+ if let Some(text) = step.text {
+ self.emit_text(text, Some(token.0));
+ }
+
+ if step.stop {
+ stop_triggered = true;
+ break;
+ }
+
+ let mut step_batch = LlamaBatch::new(1, 1);
+ step_batch
+ .add(token, pos, &[0], true)
+ .map_err(|err| Error::Llama {
+ op: "Failed to add token",
+ message: err.to_string(),
+ })?;
+ if let Err(err) = ctx.decode(&mut step_batch) {
+ ctx.clear_kv_cache();
+ if let Some(cached) = cached_tokens.as_deref_mut() {
+ cached.clear();
+ }
+ return Err(Error::Llama {
+ op: "Decode failed",
+ message: err.to_string(),
+ });
+ }
if let Some(cached) = cached_tokens.as_deref_mut() {
- cached.clear();
+ cached.push(token);
}
- return Err(Error::Llama {
- op: "Decode failed",
- message: err.to_string(),
- });
+
+ logits_index = 0;
+ pos += 1;
}
- if let Some(cached) = cached_tokens.as_deref_mut() {
- cached.push(token);
+
+ if !stop_triggered {
+ let step = decoder.flush();
+ if let Some(text) = step.text {
+ self.emit_text(text, None);
+ }
}
- logits_index = 0;
- pos += 1;
+ Ok(())
}
- if !stop_triggered {
- let step = decoder.flush();
- if let Some(text) = step.text {
- sink.add(GenerationEvent::Text {
- job_id,
- text,
- token_id: None,
- });
- }
+ fn emit_text(&mut self, text: String, token_id: Option<i32>) {
+ self.sink.add(GenerationEvent::Text {
+ job_id: self.job_id,
+ text,
+ token_id,
+ });
}
-
- Ok(())
}
fn build_sampler(model: &LlamaModel, request: &SamplingParams) -> Result<LlamaSampler, Error> {
@@ -516,8 +522,15 @@ fn generate_chat_stream(
let max_tokens = usize::try_from(max_tokens.max(0)).unwrap_or(0);
let stop_sequences = stop_sequences.unwrap_or_default();
- let mut prompt_tokens_count: i32 = 0;
- let mut generated_tokens_count: i32 = 0;
+ let mut job = GenerationJob {
+ cancel_flag: &cancel_flag,
+ sink,
+ job_id,
+ max_tokens,
+ stop_sequences: &stop_sequences,
+ prompt_tokens: 0,
+ generated_tokens: 0,
+ };
let result = match catch_unwind(AssertUnwindSafe(|| {
context.with_context_and_cache_mut(|ctx, cached_tokens| -> Result<(), Error> {
@@ -592,7 +605,7 @@ fn generate_chat_stream(
context_size: n_ctx,
});
}
- prompt_tokens_count =
+ job.prompt_tokens =
i32::try_from(prompt_tokens.len()).map_err(|_| Error::PromptTooLong {
tokens: prompt_tokens.len(),
context_size: n_ctx,
@@ -649,19 +662,7 @@ fn generate_chat_stream(
sampler.accept_many(prompt_tokens.iter());
let pos = prompt_tokens.len() as i32;
- run_generation_loop(
- ctx,
- &mut sampler,
- &cancel_flag,
- sink,
- job_id,
- max_tokens,
- &stop_sequences,
- &mut generated_tokens_count,
- Some(cached_tokens),
- pos,
- logits_index,
- )?;
+ job.run(ctx, &mut sampler, Some(cached_tokens), pos, logits_index)?;
return Ok(());
}
@@ -721,7 +722,7 @@ fn generate_chat_stream(
context_size: n_ctx,
});
}
- prompt_tokens_count =
+ job.prompt_tokens =
i32::try_from(chunks.total_tokens()).map_err(|_| Error::PromptTooLong {
tokens: chunks.total_tokens(),
context_size: n_ctx,
@@ -755,19 +756,7 @@ fn generate_chat_stream(
}
sampler.accept_many(prompt_tokens.iter());
- run_generation_loop(
- ctx,
- &mut sampler,
- &cancel_flag,
- sink,
- job_id,
- max_tokens,
- &stop_sequences,
- &mut generated_tokens_count,
- None,
- n_past,
- -1,
- )?;
+ job.run(ctx, &mut sampler, None, n_past, -1)?;
Ok(())
})
@@ -782,8 +771,8 @@ fn generate_chat_stream(
let summary = GenerationSummary {
job_id,
- prompt_tokens: Some(prompt_tokens_count),
- generated_tokens: Some(generated_tokens_count),
+ prompt_tokens: Some(job.prompt_tokens),
+ generated_tokens: Some(job.generated_tokens),
total_time_ms: Some(start.elapsed().as_millis() as i64),
};
diff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.ts
index 825db8c40c..75d6c3cc48 100644
--- a/web/apps/space/src/services/space.ts
+++ b/web/apps/space/src/services/space.ts
@@ -1309,10 +1309,12 @@ export const createCurrentPhotoPost = async ({
spaceId,
bytes,
caption?.trim() || null,
- normalizedWidth,
- normalizedHeight,
- file.type || null,
- thumbHash || null,
+ {
+ width: normalizedWidth,
+ height: normalizedHeight,
+ mediaType: file.type || null,
+ thumbHash: thumbHash || null,
+ },
)) as SpacePostResponse;
const object = firstObject(created);
if (object) await cacheAccountPostAssetURL(created, object, file);