[IMP] remove refresh_mode setting

fda-odoo · fda-odoo · commit fe6ed81e2a24 · 2025-10-22T17:06:59.000+02:00
Refresh_mode setting is creating caches errors if Off or OnSave option are selected. Off is not really useful, nor OnSave, so we will only use adaptive for everyone starting from now.

Next commit will fix these cache invalidation issue in adaptive mode. That fix is not doable in Off or OnSave mode, adding argument to the deletion of these options
diff --git a/server/src/cli_backend.rs b/server/src/cli_backend.rs
@@ -55,7 +55,6 @@ impl CliBackend {
         let mut config = ConfigEntry::new();
         config.addons_paths = addons_paths.into_iter().map(|p| fs::canonicalize(p).unwrap_or_else(|_| PathBuf::from(S!(""))).sanitize()).collect();
         config.odoo_path = Some(fs::canonicalize(community_path.unwrap_or(S!(""))).unwrap_or_else(|_| PathBuf::from(S!(""))).sanitize());
-        config.refresh_mode = crate::core::config::RefreshMode::Off;
         config.diag_missing_imports = DiagMissingImportsMode::All;
         config.no_typeshed_stubs = self.cli.no_typeshed_stubs;
         config.additional_stubs = self.cli.stubs.clone().unwrap_or(vec![]).into_iter().map(|p| fs::canonicalize(p).unwrap_or_else(|_| PathBuf::from(S!(""))).sanitize()).collect();
diff --git a/server/src/core/config.rs b/server/src/core/config.rs
@@ -22,34 +22,6 @@ static VERSION_REGEX: std::sync::LazyLock<Regex> = std::sync::LazyLock::new(|| {
     Regex::new(r#"^(\D+~)?\d+\.\d+$"#).unwrap()
 });
 
-#[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum RefreshMode {
-    OnSave,
-    Adaptive,
-    Off
-}
-impl Default for RefreshMode {
-    fn default() -> Self {
-        RefreshMode::Adaptive
-    }
-}
-
-impl FromStr for RefreshMode {
-
-    type Err = ();
-
-    fn from_str(input: &str) -> Result<RefreshMode, Self::Err> {
-        match input {
-            "afterDelay"  => Ok(RefreshMode::Adaptive),
-            "onSave"  => Ok(RefreshMode::OnSave),
-            "adaptive" => Ok(RefreshMode::Adaptive),
-            "off"  => Ok(RefreshMode::Off),
-            _      => Err(()),
-        }
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, Deserialize, Serialize, Clone, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum DiagMissingImportsMode {
@@ -620,10 +592,6 @@ pub struct ConfigEntryRaw {
     #[schemars(with = "Option<MergeMethod>")]
     additional_stubs_merge: Option<Sourced<MergeMethod>>,
 
-    #[serde(default, serialize_with = "serialize_option_as_default")]
-    #[schemars(with = "Option<RefreshMode>")]
-    refresh_mode: Option<Sourced<RefreshMode>>,
-
     #[serde(default, serialize_with = "serialize_file_cache")]
     #[schemars(with = "Option<bool>")]
     file_cache: Option<Sourced<bool>>,
@@ -708,7 +676,6 @@ impl Default for ConfigEntryRaw {
             python_path: None,
             additional_stubs: None,
             additional_stubs_merge: None,
-            refresh_mode: None,
             file_cache: None,
             diag_missing_imports: None,
             ac_filter_model_names: None,
@@ -754,7 +721,6 @@ pub struct ConfigEntry {
     pub addons_paths: HashSet<String>,
     pub python_path: String,
     pub additional_stubs: HashSet<String>,
-    pub refresh_mode: RefreshMode,
     pub file_cache: bool,
     pub diag_missing_imports: DiagMissingImportsMode,
     pub ac_filter_model_names: bool,
@@ -774,7 +740,6 @@ impl Default for ConfigEntry {
             addons_paths: HashSet::new(),
             python_path: S!(get_python_command().unwrap_or_default()),
             additional_stubs: HashSet::new(),
-            refresh_mode: RefreshMode::default(),
             file_cache: true,
             diag_missing_imports: DiagMissingImportsMode::default(),
             ac_filter_model_names: true,
@@ -915,7 +880,6 @@ fn read_config_from_file<P: AsRef<Path>>(path: P) -> Result<HashMap<String, Conf
         // Add initial source to all fields
         entry.addons_merge.as_mut().map(|sourced| sourced.sources.insert(path.sanitize()));
         entry.additional_stubs_merge.as_mut().map(|sourced| sourced.sources.insert(path.sanitize()));
-        entry.refresh_mode.as_mut().map(|sourced| sourced.sources.insert(path.sanitize()));
         entry.file_cache.as_mut().map(|sourced| sourced.sources.insert(path.sanitize()));
         entry.diag_missing_imports.as_mut().map(|sourced| sourced.sources.insert(path.sanitize()));
         entry.ac_filter_model_names.as_mut().map(|sourced| sourced.sources.insert(path.sanitize()));
@@ -992,7 +956,6 @@ fn apply_merge(child: &ConfigEntryRaw, parent: &ConfigEntryRaw) -> ConfigEntryRa
         },
         MergeMethod::Override => child.additional_stubs.clone(),
     };
-    let refresh_mode = child.refresh_mode.clone().or(parent.refresh_mode.clone());
     let file_cache = child.file_cache.clone().or(parent.file_cache.clone());
     let diag_missing_imports = child.diag_missing_imports.clone().or(parent.diag_missing_imports.clone());
     let ac_filter_model_names = child.ac_filter_model_names.clone().or(parent.ac_filter_model_names.clone());
@@ -1013,7 +976,6 @@ fn apply_merge(child: &ConfigEntryRaw, parent: &ConfigEntryRaw) -> ConfigEntryRa
         python_path,
         addons_paths,
         additional_stubs,
-        refresh_mode,
         file_cache,
         diag_missing_imports,
         ac_filter_model_names,
@@ -1314,12 +1276,6 @@ fn merge_all_workspaces(
                 (Some(paths), None) | (None, Some(paths)) => Some(paths),
                 (None, None) => None,
             };
-            merged_entry.refresh_mode = merge_sourced_options(
-                merged_entry.refresh_mode.clone(),
-                raw_entry.refresh_mode.clone(),
-                key.clone(),
-                "refresh_mode".to_string(),
-            )?;
             merged_entry.file_cache = merge_sourced_options(
                 merged_entry.file_cache.clone(),
                 raw_entry.file_cache.clone(),
@@ -1393,7 +1349,6 @@ fn merge_all_workspaces(
                 addons_paths: raw_entry.addons_paths.into_iter().flatten().map(|op| op.value).collect(),
                 python_path: raw_entry.python_path.map(|op| op.value).unwrap_or(S!(get_python_command().unwrap_or_default())),
                 additional_stubs: raw_entry.additional_stubs.into_iter().flatten().map(|op| op.value).collect(),
-                refresh_mode: raw_entry.refresh_mode.map(|op| op.value).unwrap_or_default(),
                 file_cache: raw_entry.file_cache.map(|op| op.value).unwrap_or(true),
                 diag_missing_imports: raw_entry.diag_missing_imports.map(|op| op.value).unwrap_or_default(),
                 ac_filter_model_names: raw_entry.ac_filter_model_names.map(|op| op.value).unwrap_or(true),
diff --git a/server/src/core/odoo.rs b/server/src/core/odoo.rs
@@ -30,7 +30,7 @@ use std::path::{Path, PathBuf};
 use std::env;
 use regex::Regex;
 use crate::{constants::*, oyarn, Sy};
-use super::config::{self, default_profile_name, get_configuration, ConfigEntry, ConfigFile, RefreshMode};
+use super::config::{self, default_profile_name, get_configuration, ConfigEntry, ConfigFile};
 use super::entry_point::{EntryPoint, EntryPointMgr};
 use super::file_mgr::FileMgr;
 use super::import_resolver::ImportCache;
@@ -1372,7 +1372,7 @@ impl Odoo {
     }
 
     fn handle_file_update(session: &mut SessionInfo, file_uris: &Vec<Uri>) {
-        if session.sync_odoo.config.refresh_mode == RefreshMode::Off || session.sync_odoo.state_init == InitState::NOT_READY {
+        if session.sync_odoo.state_init == InitState::NOT_READY {
             return
         }
         for uri in file_uris.iter() {
@@ -1383,7 +1383,7 @@ impl Odoo {
             session.log_message(MessageType::INFO, format!("File update: {}", path.sanitize()));
             let (valid, updated) = Odoo::update_file_cache(session, path.clone(), None, -100);
             if valid && updated {
-                Odoo::update_file_index(session, path, true, false, true);
+                Odoo::update_file_index(session, path, false, true);
             }
         }
     }
@@ -1399,7 +1399,7 @@ impl Odoo {
                     text: params.text_document.text}]), params.text_document.version);
             if valid {
                 session.sync_odoo.opened_files.push(path.sanitize());
-                if session.sync_odoo.config.refresh_mode == RefreshMode::Off || session.sync_odoo.state_init == InitState::NOT_READY {
+                if session.sync_odoo.state_init == InitState::NOT_READY {
                     return
                 }
                 let tree = session.sync_odoo.path_to_main_entry_tree(&path);
@@ -1413,15 +1413,15 @@ impl Odoo {
                     for custom_entry in ep_mgr.borrow().custom_entry_points.iter() {
                         if custom_entry.borrow().path == tree_path.sanitize() {
                             if updated{
-                                Odoo::update_file_index(session, path,true, true, false);
+                                Odoo::update_file_index(session, path, true, false);
                             }
                             return;
                         }
                     }
                     EntryPointMgr::create_new_custom_entry_for_path(session, &tree_path.sanitize(), &path.sanitize());
                     SyncOdoo::process_rebuilds(session);
                 } else if updated {
-                    Odoo::update_file_index(session, path,true, true, false);
+                    Odoo::update_file_index(session, path, true, false);
                 }
             }
         }
@@ -1487,7 +1487,7 @@ impl Odoo {
     }
 
     pub fn handle_did_rename(session: &mut SessionInfo, params: RenameFilesParams) {
-        if session.sync_odoo.config.refresh_mode == RefreshMode::Off || session.sync_odoo.state_init == InitState::NOT_READY {
+        if session.sync_odoo.state_init == InitState::NOT_READY {
             return
         }
         for f in params.files.iter() {
@@ -1518,7 +1518,7 @@ impl Odoo {
     }
 
     pub fn handle_did_create(session: &mut SessionInfo, params: CreateFilesParams) {
-        if session.sync_odoo.config.refresh_mode == RefreshMode::Off || session.sync_odoo.state_init == InitState::NOT_READY {
+        if session.sync_odoo.state_init == InitState::NOT_READY {
             return
         }
         for f in params.files.iter() {
@@ -1543,7 +1543,7 @@ impl Odoo {
     }
 
     pub fn handle_did_delete(session: &mut SessionInfo, params: DeleteFilesParams) {
-        if session.sync_odoo.config.refresh_mode == RefreshMode::Off || session.sync_odoo.state_init == InitState::NOT_READY {
+        if session.sync_odoo.state_init == InitState::NOT_READY {
             return
         }
         for f in params.files.iter() {
@@ -1563,10 +1563,10 @@ impl Odoo {
             let version = params.text_document.version;
             let (valid, updated) = Odoo::update_file_cache(session, path.clone(), Some(&params.content_changes), version);
             if valid && updated {
-                if (matches!(session.sync_odoo.config.refresh_mode, RefreshMode::Off | RefreshMode::OnSave)) || session.sync_odoo.state_init == InitState::NOT_READY {
+                if session.sync_odoo.state_init == InitState::NOT_READY {
                     return
                 }
-                Odoo::update_file_index(session, path, false, false, false);
+                Odoo::update_file_index(session, path, false, false);
             }
         }
     }
@@ -1577,10 +1577,9 @@ impl Odoo {
             return; //config file update, handled by the config file handler
         }
         session.log_message(MessageType::INFO, format!("File saved: {}", path.sanitize()));
-        if session.sync_odoo.config.refresh_mode != RefreshMode::OnSave || session.sync_odoo.state_init == InitState::NOT_READY {
-            return
-        }
-        Odoo::update_file_index(session, path,true, false, false);
+        return;
+        //No need to update the index on save, as the file change event will do it
+        //Odoo::update_file_index(session, path,true, false, false);
     }
 
     // return (valid, updated) booleans
@@ -1595,9 +1594,9 @@ impl Odoo {
         (false, false)
     }
 
-    pub fn update_file_index(session: &mut SessionInfo, path: PathBuf, is_save: bool, _is_open: bool, force_delay: bool) {
+    pub fn update_file_index(session: &mut SessionInfo, path: PathBuf, _is_open: bool, force_delay: bool) {
         if matches!(path.extension().and_then(OsStr::to_str), Some(ext) if ["py", "xml", "csv"].contains(&ext)) || Odoo::is_config_workspace_file(session, &path){
-            SessionInfo::request_update_file_index(session, &path, is_save, force_delay);
+            SessionInfo::request_update_file_index(session, &path, force_delay);
         }
     }
 
diff --git a/server/src/threads.rs b/server/src/threads.rs
@@ -9,7 +9,7 @@ use serde::{de::DeserializeOwned, Serialize};
 use serde_json::Value;
 use tracing::{error, info, warn};
 
-use crate::{core::{config::RefreshMode, file_mgr::NoqaInfo, odoo::{Odoo, SyncOdoo}}, server::ServerError, utils::PathSanitizer, S};
+use crate::{core::{file_mgr::NoqaInfo, odoo::{Odoo, SyncOdoo}}, server::ServerError, utils::PathSanitizer, S};
 
 pub struct SessionInfo<'a> {
     sender: Sender<Message>,
@@ -93,36 +93,21 @@ impl <'a> SessionInfo<'a> {
     /*
     * Request an update of the file in the index.
     * path: path of the file
-    * process_now: indicate if the current action is due to a save action
     * forced_delay: indicate that we want to force a delay
      */
-    pub fn request_update_file_index(session: &mut SessionInfo, path: &PathBuf, is_save: bool, forced_delay: bool) {
+    pub fn request_update_file_index(session: &mut SessionInfo, path: &PathBuf, forced_delay: bool) {
         if (!forced_delay || session.delayed_process_sender.is_none()) && !session.sync_odoo.need_rebuild {
-            if session.sync_odoo.config.refresh_mode == RefreshMode::OnSave {
-                if is_save {
-                    let _ = SyncOdoo::_unload_path(session, &path, false);
-                    Odoo::search_symbols_to_rebuild(session, &path.sanitize());
-                    SyncOdoo::process_rebuilds(session);
-                }
-                return;
-            }
-            if session.sync_odoo.config.refresh_mode == RefreshMode::Adaptive &&
-            session.sync_odoo.get_rebuild_queue_size() < 10 {
+            if session.sync_odoo.get_rebuild_queue_size() < 10 {
                 let _ = SyncOdoo::_unload_path(session, &path, false);
                 Odoo::search_symbols_to_rebuild(session, &path.sanitize());
                 SyncOdoo::process_rebuilds(session);
-            } else {
-                if forced_delay {
-                    session.sync_odoo.watched_file_updates.store(session.sync_odoo.watched_file_updates.load(Ordering::SeqCst) + 1, Ordering::SeqCst);
-                }
-                let _ = session.delayed_process_sender.as_ref().unwrap().send(DelayedProcessingMessage::UPDATE_FILE_INDEX(UpdateFileIndexData { path: path.clone(), time: std::time::Instant::now(), forced_delay}));
-            }
-        } else {
-            if forced_delay {
-                session.sync_odoo.watched_file_updates.store(session.sync_odoo.watched_file_updates.load(Ordering::SeqCst) + 1, Ordering::SeqCst);
+                return;
             }
-            let _ = session.delayed_process_sender.as_ref().unwrap().send(DelayedProcessingMessage::UPDATE_FILE_INDEX(UpdateFileIndexData { path: path.clone(), time: std::time::Instant::now(), forced_delay}));
+        } 
+        if forced_delay {
+            session.sync_odoo.watched_file_updates.store(session.sync_odoo.watched_file_updates.load(Ordering::SeqCst) + 1, Ordering::SeqCst);
         }
+        let _ = session.delayed_process_sender.as_ref().unwrap().send(DelayedProcessingMessage::UPDATE_FILE_INDEX(UpdateFileIndexData { path: path.clone(), time: std::time::Instant::now(), forced_delay}));
     }
 
     pub fn request_reload(session: &mut SessionInfo) {
diff --git a/server/tests/config_tests.rs b/server/tests/config_tests.rs
@@ -561,40 +561,6 @@ fn test_no_conflict_when_config_files_point_to_same_odoo_path() {
     assert_eq!(config.odoo_path.as_ref().unwrap(), &ws1.path().sanitize());
 }
 
-#[test]
-fn test_conflict_between_config_files_on_refresh_mode() {
-    let temp = TempDir::new().unwrap();
-    let ws1 = temp.child("ws1");
-    let ws2 = temp.child("ws2");
-    ws1.create_dir_all().unwrap();
-    ws2.create_dir_all().unwrap();
-
-    // ws1 config: refresh_mode = "onSave"
-    let ws1_toml = r#"
-        [[config]]
-        name = "default"
-        refresh_mode = "on_save"
-    "#;
-    ws1.child("odools.toml").write_str(ws1_toml).unwrap();
-
-    // ws2 config: refresh_mode = "adaptive"
-    let ws2_toml = r#"
-        [[config]]
-        name = "default"
-        refresh_mode = "adaptive"
-    "#;
-    ws2.child("odools.toml").write_str(ws2_toml).unwrap();
-
-    let mut ws_folders = HashMap::new();
-    ws_folders.insert(S!("ws1"), ws1.path().sanitize().to_string());
-    ws_folders.insert(S!("ws2"), ws2.path().sanitize().to_string());
-
-    // Should error due to conflicting refresh_mode values
-    let result = get_configuration(&ws_folders, &None);
-    assert!(result.is_err());
-    assert!(result.err().unwrap().contains("Conflict detected"));
-}
-
 #[test]
 fn test_merge_different_odoo_paths_and_addons_paths() {
     let temp = TempDir::new().unwrap();
diff --git a/server/tests/setup/setup.rs b/server/tests/setup/setup.rs
@@ -51,7 +51,6 @@ pub fn setup_server(with_odoo: bool) -> SyncOdoo {
         panic!("Python not found")
     };
     config.python_path = python_cmd;
-    config.refresh_mode = odoo_ls_server::core::config::RefreshMode::Off;
     config.diag_missing_imports = DiagMissingImportsMode::All;
 
     let (s, r) = crossbeam_channel::unbounded();

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ use std::path::{Path, PathBuf};`
`30`	`30`	`use std::env;`
`31`	`31`	`use regex::Regex;`
`32`	`32`	`use crate::{constants::*, oyarn, Sy};`
`33`		`-use super::config::{self, default_profile_name, get_configuration, ConfigEntry, ConfigFile, RefreshMode};`
	`33`	`+use super::config::{self, default_profile_name, get_configuration, ConfigEntry, ConfigFile};`
`34`	`34`	`use super::entry_point::{EntryPoint, EntryPointMgr};`
`35`	`35`	`use super::file_mgr::FileMgr;`
`36`	`36`	`use super::import_resolver::ImportCache;`
`@@ -1372,7 +1372,7 @@ impl Odoo {`
`1372`	`1372`	`}`
`1373`	`1373`
`1374`	`1374`	`fn handle_file_update(session: &mut SessionInfo, file_uris: &Vec<Uri>) {`
`1375`		`- if session.sync_odoo.config.refresh_mode == RefreshMode::Off \|\| session.sync_odoo.state_init == InitState::NOT_READY {`
	`1375`	`+ if session.sync_odoo.state_init == InitState::NOT_READY {`
`1376`	`1376`	`return`
`1377`	`1377`	`}`
`1378`	`1378`	`for uri in file_uris.iter() {`
`@@ -1383,7 +1383,7 @@ impl Odoo {`
`1383`	`1383`	`session.log_message(MessageType::INFO, format!("File update: {}", path.sanitize()));`
`1384`	`1384`	`let (valid, updated) = Odoo::update_file_cache(session, path.clone(), None, -100);`
`1385`	`1385`	`if valid && updated {`
`1386`		`- Odoo::update_file_index(session, path, true, false, true);`
	`1386`	`+ Odoo::update_file_index(session, path, false, true);`
`1387`	`1387`	`}`
`1388`	`1388`	`}`
`1389`	`1389`	`}`
`@@ -1399,7 +1399,7 @@ impl Odoo {`
`1399`	`1399`	`text: params.text_document.text}]), params.text_document.version);`
`1400`	`1400`	`if valid {`
`1401`	`1401`	`session.sync_odoo.opened_files.push(path.sanitize());`
`1402`		`- if session.sync_odoo.config.refresh_mode == RefreshMode::Off \|\| session.sync_odoo.state_init == InitState::NOT_READY {`
	`1402`	`+ if session.sync_odoo.state_init == InitState::NOT_READY {`
`1403`	`1403`	`return`
`1404`	`1404`	`}`
`1405`	`1405`	`let tree = session.sync_odoo.path_to_main_entry_tree(&path);`
`@@ -1413,15 +1413,15 @@ impl Odoo {`
`1413`	`1413`	`for custom_entry in ep_mgr.borrow().custom_entry_points.iter() {`
`1414`	`1414`	`if custom_entry.borrow().path == tree_path.sanitize() {`
`1415`	`1415`	`if updated{`
`1416`		`- Odoo::update_file_index(session, path,true, true, false);`
	`1416`	`+ Odoo::update_file_index(session, path, true, false);`
`1417`	`1417`	`}`
`1418`	`1418`	`return;`
`1419`	`1419`	`}`
`1420`	`1420`	`}`
`1421`	`1421`	`EntryPointMgr::create_new_custom_entry_for_path(session, &tree_path.sanitize(), &path.sanitize());`
`1422`	`1422`	`SyncOdoo::process_rebuilds(session);`
`1423`	`1423`	`} else if updated {`
`1424`		`- Odoo::update_file_index(session, path,true, true, false);`
	`1424`	`+ Odoo::update_file_index(session, path, true, false);`
`1425`	`1425`	`}`
`1426`	`1426`	`}`
`1427`	`1427`	`}`
`@@ -1487,7 +1487,7 @@ impl Odoo {`
`1487`	`1487`	`}`
`1488`	`1488`
`1489`	`1489`	`pub fn handle_did_rename(session: &mut SessionInfo, params: RenameFilesParams) {`
`1490`		`- if session.sync_odoo.config.refresh_mode == RefreshMode::Off \|\| session.sync_odoo.state_init == InitState::NOT_READY {`
	`1490`	`+ if session.sync_odoo.state_init == InitState::NOT_READY {`
`1491`	`1491`	`return`
`1492`	`1492`	`}`
`1493`	`1493`	`for f in params.files.iter() {`
`@@ -1518,7 +1518,7 @@ impl Odoo {`
`1518`	`1518`	`}`
`1519`	`1519`
`1520`	`1520`	`pub fn handle_did_create(session: &mut SessionInfo, params: CreateFilesParams) {`
`1521`		`- if session.sync_odoo.config.refresh_mode == RefreshMode::Off \|\| session.sync_odoo.state_init == InitState::NOT_READY {`
	`1521`	`+ if session.sync_odoo.state_init == InitState::NOT_READY {`
`1522`	`1522`	`return`
`1523`	`1523`	`}`
`1524`	`1524`	`for f in params.files.iter() {`
`@@ -1543,7 +1543,7 @@ impl Odoo {`
`1543`	`1543`	`}`
`1544`	`1544`
`1545`	`1545`	`pub fn handle_did_delete(session: &mut SessionInfo, params: DeleteFilesParams) {`
`1546`		`- if session.sync_odoo.config.refresh_mode == RefreshMode::Off \|\| session.sync_odoo.state_init == InitState::NOT_READY {`
	`1546`	`+ if session.sync_odoo.state_init == InitState::NOT_READY {`
`1547`	`1547`	`return`
`1548`	`1548`	`}`
`1549`	`1549`	`for f in params.files.iter() {`
`@@ -1563,10 +1563,10 @@ impl Odoo {`
`1563`	`1563`	`let version = params.text_document.version;`
`1564`	`1564`	`let (valid, updated) = Odoo::update_file_cache(session, path.clone(), Some(&params.content_changes), version);`
`1565`	`1565`	`if valid && updated {`
`1566`		`- if (matches!(session.sync_odoo.config.refresh_mode, RefreshMode::Off \| RefreshMode::OnSave)) \|\| session.sync_odoo.state_init == InitState::NOT_READY {`
	`1566`	`+ if session.sync_odoo.state_init == InitState::NOT_READY {`
`1567`	`1567`	`return`
`1568`	`1568`	`}`
`1569`		`- Odoo::update_file_index(session, path, false, false, false);`
	`1569`	`+ Odoo::update_file_index(session, path, false, false);`
`1570`	`1570`	`}`
`1571`	`1571`	`}`
`1572`	`1572`	`}`
`@@ -1577,10 +1577,9 @@ impl Odoo {`
`1577`	`1577`	`return; //config file update, handled by the config file handler`
`1578`	`1578`	`}`
`1579`	`1579`	`session.log_message(MessageType::INFO, format!("File saved: {}", path.sanitize()));`
`1580`		`- if session.sync_odoo.config.refresh_mode != RefreshMode::OnSave \|\| session.sync_odoo.state_init == InitState::NOT_READY {`
`1581`		`- return`
`1582`		`- }`
`1583`		`- Odoo::update_file_index(session, path,true, false, false);`
	`1580`	`+ return;`
	`1581`	`+ //No need to update the index on save, as the file change event will do it`
	`1582`	`+ //Odoo::update_file_index(session, path,true, false, false);`
`1584`	`1583`	`}`
`1585`	`1584`
`1586`	`1585`	`// return (valid, updated) booleans`
`@@ -1595,9 +1594,9 @@ impl Odoo {`
`1595`	`1594`	`(false, false)`
`1596`	`1595`	`}`
`1597`	`1596`
`1598`		`- pub fn update_file_index(session: &mut SessionInfo, path: PathBuf, is_save: bool, _is_open: bool, force_delay: bool) {`
	`1597`	`+ pub fn update_file_index(session: &mut SessionInfo, path: PathBuf, _is_open: bool, force_delay: bool) {`
`1599`	`1598`	`if matches!(path.extension().and_then(OsStr::to_str), Some(ext) if ["py", "xml", "csv"].contains(&ext)) \|\| Odoo::is_config_workspace_file(session, &path){`
`1600`		`- SessionInfo::request_update_file_index(session, &path, is_save, force_delay);`
	`1599`	`+ SessionInfo::request_update_file_index(session, &path, force_delay);`
`1601`	`1600`	`}`
`1602`	`1601`	`}`
`1603`	`1602`