Upgraded to Rust 2024 edition

Author: dialogflowchatbot

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "dialogflow"
 version = "1.17.6"
-edition = "2021"
+edition = "2024"
 homepage = "https://dialogflowchatbot.github.io/"
 authors = ["dialogflowchatbot <dialogflow@yeah.net>"]
 

build.rs

@@ -6,7 +6,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use flate2::{write::GzEncoder, Compression};
+use flate2::{Compression, write::GzEncoder};
 
 fn walk_assets(path: impl AsRef<Path>) -> Result<Vec<PathBuf>, std::io::Error> {
     let mut files: Vec<PathBuf> = Vec::new();

src/ai/asr.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use super::huggingface::{load_bert_model_files, HuggingFaceModel, HuggingFaceModelInfo};
+use super::huggingface::HuggingFaceModel;
 
 #[derive(Clone, Deserialize, Serialize)]
 #[serde(tag = "id", content = "model")]

src/ai/crud.rs

@@ -9,8 +9,8 @@ use futures::future::Either;
 use futures::stream::{self, Stream};
 use serde::{Deserialize, Serialize};
 use tokio::sync::mpsc;
-use tokio_stream::wrappers::ReceiverStream;
 use tokio_stream::StreamExt as _;
+use tokio_stream::wrappers::ReceiverStream;
 
 use crate::ai::completion;
 

src/ai/embedding.rs

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use tokenizers::Tokenizer;
 
-use super::huggingface::{load_bert_model_files, HuggingFaceModel, HuggingFaceModelInfo};
+use super::huggingface::{HuggingFaceModel, HuggingFaceModelInfo, load_bert_model_files};
 use crate::man::settings;
 use crate::result::{Error, Result};
 
@@ -77,7 +77,7 @@ fn hugging_face(robot_id: &str, info: &HuggingFaceModelInfo, s: &str) -> Result<
         let r = load_bert_model_files(&info.repository)?;
         model.insert(String::from(robot_id), r);
     };
-    let (m, ref mut t) = model.get_mut(robot_id).unwrap();
+    let (m, t) = model.get_mut(robot_id).unwrap();
     // let tokenizer = match t.with_padding(None).with_truncation(None) {
     //     Ok(t) => t,
     //     Err(e) => return Err(Error::ErrorWithMessage(format!("{}", &e))),

src/ai/gemma.rs

@@ -52,7 +52,7 @@ pub(super) fn gen_text(
         None => {
             return Err(Error::ErrorWithMessage(String::from(
                 "cannot find the <eos> token",
-            )))
+            )));
         }
     };
     let mut generated_tokens = 0usize;
@@ -81,7 +81,7 @@ pub(super) fn gen_text(
 
         let mut rng = Rand::new();
         let mut logits_processor = LogitsProcessor::new(
-            rng.gen::<u64>(),
+            rng.r#gen::<u64>(),
             Some(super::completion::TEMPERATURE),
             top_p,
         );

src/ai/huggingface.rs

@@ -853,13 +853,13 @@ fn load_safetensors(mirror: &str, json_file: &str) -> Result<Vec<String>> {
         None => {
             return Err(Error::ErrorWithMessage(format!(
                 "no weight map in {json_file:?}"
-            )))
+            )));
         }
         Some(serde_json::Value::Object(map)) => map,
         Some(_) => {
             return Err(Error::ErrorWithMessage(format!(
                 "weight map in {json_file:?} is not a map"
-            )))
+            )));
         }
     };
     let mut safetensors_files = std::collections::HashSet::new();

src/ai/llama.rs

@@ -85,7 +85,7 @@ pub(super) fn gen_text(
             }
         };
         let mut rng = Rand::new();
-        LogitsProcessor::from_sampling(rng.gen::<u64>(), sampling)
+        LogitsProcessor::from_sampling(rng.r#gen::<u64>(), sampling)
     };
     // log::info!("logits_processor finished");
     let start_gen = std::time::Instant::now();
@@ -125,7 +125,7 @@ pub(super) fn gen_text(
             Some(LlamaEosToks::Single(eos_tok_id)) if next_token == *eos_tok_id => {
                 break;
             }
-            Some(LlamaEosToks::Multiple(ref eos_ids)) if eos_ids.contains(&next_token) => {
+            Some(LlamaEosToks::Multiple(eos_ids)) if eos_ids.contains(&next_token) => {
                 break;
             }
             _ => (),

src/ai/phi3.rs

@@ -59,7 +59,7 @@ pub(super) fn gen_text(
         None => {
             return Err(Error::ErrorWithMessage(String::from(
                 "cannot find the endoftext token",
-            )))
+            )));
         }
     };
     // log::info!("{prompt}");
@@ -69,7 +69,7 @@ pub(super) fn gen_text(
     let mut rng = Rand::new();
     let mut model = model.clone();
     let mut logits_processor = LogitsProcessor::new(
-        rng.gen::<u64>(),
+        rng.r#gen::<u64>(),
         Some(super::completion::TEMPERATURE),
         top_p,
     );

src/ai/tts.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use super::huggingface::{load_bert_model_files, HuggingFaceModel, HuggingFaceModelInfo};
+use super::huggingface::HuggingFaceModel;
 
 #[derive(Clone, Deserialize, Serialize)]
 #[serde(tag = "id", content = "model")]

src/db/mod.rs

@@ -1,7 +1,7 @@
 // pub(crate) mod embedding;
 // pub(crate) mod embedding_sqlite;
 
-use std::borrow::{Borrow, Cow};
+use std::borrow::Borrow;
 use std::sync::LazyLock;
 use std::vec::Vec;
 
@@ -386,7 +386,7 @@ pub(crate) async fn init_sqlite_datasource(
             return Err(Error::ErrorWithMessage(format!(
                 "Created database file failed, err: {:?}",
                 &e
-            )))
+            )));
         }
     };
     let pool_ops = sqlx::pool::PoolOptions::<sqlx::Sqlite>::new()

src/external/http/client.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 use std::time::Duration;
 use std::vec::Vec;
 
-use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 use reqwest::Client;
 use reqwest::RequestBuilder;
+use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 
 use super::dto::{HttpReqInfo, Method, PostContentType, Protocol, ResponseData, ValueSource};
 use crate::result::Result;

src/external/http/crud.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 
+use axum::Json;
 use axum::extract::{Path, Query};
 use axum::response::IntoResponse;
-use axum::Json;
 
 use super::dto::HttpReqInfo;
 use crate::db;

src/flow/mainflow/crud.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::sync::{LazyLock, OnceLock};
 
 use axum::extract::Query;
-use axum::{response::IntoResponse, Json};
+use axum::{Json, response::IntoResponse};
 // use redb::TableDefinition;
 use std::sync::Mutex;
 

src/flow/rt/context.rs

@@ -6,7 +6,7 @@ use std::vec::Vec;
 
 // use erased_serde::{Deserialize, Serialize};
 use serde::{Deserialize, Serialize};
-use tokio::time::{interval, Duration};
+use tokio::time::{Duration, interval};
 
 use super::node::RuntimeNnodeEnum;
 use crate::ai::completion::Prompt;

src/flow/rt/convertor.rs

@@ -69,7 +69,7 @@ fn check_first_node(
             let first_node_id = if flow_idx == 0 { mainflow_id } else { &f.id };
             if node.get_node_id().eq(&id) {
                 match node {
-                    Node::DialogNode(ref mut n) => n.node_id = String::from(first_node_id),
+                    Node::DialogNode(n) => n.node_id = String::from(first_node_id),
                     Node::LlmChatNode(n) => n.node_id = String::from(first_node_id),
                     Node::ConditionNode(n) => n.node_id = String::from(first_node_id),
                     Node::CollectNode(n) => n.node_id = String::from(first_node_id),
@@ -244,7 +244,7 @@ fn convert_node(main_flow_id: &str, node: &mut Node) -> Result<()> {
                     _ => {
                         return Err(Error::ErrorWithMessage(String::from(
                             "Unknown collection branch type",
-                        )))
+                        )));
                     }
                 };
             }

src/flow/rt/facade.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 use std::sync::{LazyLock, Mutex};
 
-use axum::response::IntoResponse;
 use axum::Json;
+use axum::response::IntoResponse;
 use tokio::sync::mpsc::Sender;
 
 use super::dto::Request;

src/flow/rt/node.rs

@@ -3,7 +3,7 @@ use core::time::Duration;
 
 use enum_dispatch::enum_dispatch;
 use lettre::transport::smtp::PoolConfig;
-use rkyv::{util::AlignedVec, Archive, Deserialize, Serialize};
+use rkyv::{Archive, Deserialize, Serialize, util::AlignedVec};
 
 use super::condition::ConditionData;
 use super::context::Context;
@@ -273,11 +273,11 @@ impl SendEmailNode {
     fn send_email(&self, settings: &crate::man::settings::Settings) -> Result<()> {
         use lettre::transport::smtp::authentication::Credentials;
         use lettre::{
+            AsyncSmtpTransport, AsyncTransport, SmtpTransport, Tokio1Executor, Transport,
             message::{
-                header::{self, Bcc, Cc, ContentType, To},
-                Mailboxes, MessageBuilder, SinglePart,
+                Mailboxes, MessageBuilder,
+                header::{Bcc, Cc, ContentType, To},
             },
-            AsyncSmtpTransport, AsyncTransport, Message, SmtpTransport, Tokio1Executor, Transport,
         };
         let mailboxes: Mailboxes = self.to_recipients.join(",").parse()?;
         let to_header: To = mailboxes.into();

src/flow/subflow/crud.rs

@@ -1,9 +1,9 @@
 use std::sync::{LazyLock, Mutex};
 
+use axum::Json;
 use axum::extract::Query;
-use axum::http::{header::HeaderMap, StatusCode};
+use axum::http::{StatusCode, header::HeaderMap};
 use axum::response::{IntoResponse, Response};
-use axum::Json;
 // use redb::TableDefinition;
 
 use super::dto::{SubFlowDetail, SubFlowFormData};

src/intent/crud.rs

@@ -1,9 +1,9 @@
 use std::collections::HashMap;
 use std::vec::Vec;
 
+use axum::Json;
 use axum::extract::Query;
 use axum::response::IntoResponse;
-use axum::Json;
 
 use super::detector;
 use super::dto::{IntentDetail, IntentFormData, IntentPhraseData};

src/intent/detector.rs

@@ -6,7 +6,7 @@ use super::phrase;
 use crate::ai::embedding::embedding;
 use crate::db;
 use crate::db_executor;
-use crate::result::{Error, Result};
+use crate::result::Result;
 
 pub(crate) async fn detect(robot_id: &str, s: &str) -> Result<Option<String>> {
     // let now = std::time::Instant::now();

src/intent/phrase.rs

@@ -1,12 +1,8 @@
-use core::time::Duration;
-
-use std::collections::HashMap;
-use std::fs::OpenOptions;
-use std::sync::{LazyLock, Mutex, OnceLock};
+use std::sync::OnceLock;
 use std::vec::Vec;
 
 use futures_util::StreamExt;
-use sqlx::{pool::PoolOptions, Row, Sqlite};
+use sqlx::{Row, Sqlite};
 
 use super::dto::IntentPhraseData;
 use crate::ai::embedding::embedding;
@@ -165,7 +161,10 @@ pub(crate) async fn add(
                 .execute(&mut **txn)
                 .await?
                 .last_insert_rowid();
-            let sql = format!("INSERT INTO {} (id, intent_id, intent_name, phrase, phrase_vec)VALUES(?, ?, ?, ?, ?)", robot_id);
+            let sql = format!(
+                "INSERT INTO {} (id, intent_id, intent_name, phrase, phrase_vec)VALUES(?, ?, ?, ?, ?)",
+                robot_id
+            );
             sqlx::query::<Sqlite>(&sql)
                 .bind(last_insert_rowid)
                 .bind(intent_id)

src/kb/crud.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 use std::path::Path;
 
 use axum::{
+    Json,
     extract::{Multipart, Query},
     response::IntoResponse,
-    Json,
 };
 
 use super::doc;

src/kb/doc.rs

@@ -1,17 +1,14 @@
-use core::time::Duration;
-
 // use std::fs::File;
 // use std::io::Read;
 // use std::path::Path;
-use std::fs::OpenOptions;
-use std::io::{BufReader, Cursor, Read};
+use std::io::{Cursor, Read};
 use std::sync::OnceLock;
 use std::vec::Vec;
 
 use futures_util::StreamExt;
-use quick_xml::events::Event;
 use quick_xml::Reader;
-use sqlx::{pool::PoolOptions, Row, Sqlite};
+use quick_xml::events::Event;
+use sqlx::{Row, Sqlite};
 use zip::ZipArchive;
 
 use super::dto::DocData;

src/main.rs

@@ -12,7 +12,9 @@ use dialogflow::web::server::start_app;
 
 fn main() {
     // dialogflow::web::t1();
-    env::set_var("RUST_LOG", "INFO");
+    unsafe {
+        env::set_var("RUST_LOG", "INFO");
+    }
     let mut builder = LoggerBuilder::from_default_env();
     builder
         .target(Target::Stdout)

src/man/settings.rs

@@ -3,10 +3,10 @@ use std::default::Default;
 use std::net::SocketAddr;
 use std::sync::{LazyLock, Mutex};
 
+use axum::Json;
 use axum::body::Bytes;
 use axum::extract::Query;
 use axum::response::IntoResponse;
-use axum::Json;
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 
@@ -393,8 +393,8 @@ pub(crate) async fn smtp_test(Json(settings): Json<Settings>) -> impl IntoRespon
 }
 
 pub(crate) fn check_smtp_settings(settings: &Settings) -> Result<bool> {
-    use lettre::transport::smtp::authentication::Credentials;
     use lettre::SmtpTransport;
+    use lettre::transport::smtp::authentication::Credentials;
     let creds = Credentials::new(
         settings.smtp_username.to_owned(),
         settings.smtp_password.to_owned(),

src/robot/crud.rs

@@ -3,7 +3,7 @@ use std::path::Path;
 use std::vec::Vec;
 
 use axum::extract::Query;
-use axum::{response::IntoResponse, Json};
+use axum::{Json, response::IntoResponse};
 use redb::TableDefinition;
 
 use super::dto::{RobotData, RobotQuery, RobotType};
@@ -22,8 +22,8 @@ const TABLE: TableDefinition<&str, &[u8]> = TableDefinition::new("robots");
 fn get_robot_id() -> String {
     let mut id = String::with_capacity(32);
     id.push('r');
-    let gen = scru128::new_string();
-    id.push_str(&gen);
+    let gen_id = scru128::new_string();
+    id.push_str(&gen_id);
     id
 }
 

src/variable/crud.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 // use std::borrow::BorrowMut;
 use std::vec::Vec;
 
+use axum::Json;
 use axum::extract::Query;
 use axum::response::IntoResponse;
-use axum::Json;
 
 use super::dto::Variable;
 use super::dto::{VariableObtainValueExpressionType, VariableType, VariableValueSource};