pyproject.toml

@@ -21,7 +21,6 @@
       "sqlalchemy",
         "textual",
         "tomli",
-        "tomli_w"
 
 
     ]

src/pilgrim/application.py

@@ -1,20 +1,20 @@
 from pilgrim.database import Database
 from pilgrim.service.servicemanager import ServiceManager
 from pilgrim.ui.ui import UIApp
-from pilgrim.utils import ConfigManager
+from pilgrim.utils import DirectoryManager, ConfigManager
 
 
 class Application:
     def __init__(self):
+        self.config_dir = DirectoryManager.get_config_directory()
+        self.database = Database()
         self.config_manager = ConfigManager()
-        self.database = Database(self.config_manager)
         session = self.database.session()
         session_manager = ServiceManager()
         session_manager.set_session(session)
         self.ui = UIApp(session_manager,self.config_manager)
 
     def run(self):
-        self.config_manager.read_config()
         self.database.create()
         self.ui.run()
 

src/pilgrim/database.py

@@ -5,17 +5,38 @@ from pathlib import Path
 import os
 import shutil
 
-from pilgrim.utils import ConfigManager
-
 Base = declarative_base()
 
+def get_database_path() -> Path:
+    """
+    Get the database file path following XDG Base Directory specification.
+    Creates the directory if it doesn't exist.
+    """
+    # Get home directory
+    home = Path.home()
     
+    # Create .pilgrim directory if it doesn't exist
+    pilgrim_dir = home / ".pilgrim"
+    pilgrim_dir.mkdir(exist_ok=True)
+    
+    # Database file path
+    db_path = pilgrim_dir / "database.db"
+    
+    # If database doesn't exist in new location but exists in current directory,
+    # migrate it
+    if not db_path.exists():
+        current_db = Path("database.db")
+        if current_db.exists():
+            shutil.copy2(current_db, db_path)
+            print(f"Database migrated from {current_db} to {db_path}")
+    
+    return db_path
 
 class Database:
-    def __init__(self,config_manager:ConfigManager):
+    def __init__(self):
-        db_path = config_manager.database_url
+        db_path = get_database_path()
         self.engine = create_engine(
-            f"sqlite:///{config_manager.database_url}",
+            f"sqlite:///{db_path}",
             echo=False,
             connect_args={"check_same_thread": False},
         )

src/pilgrim/utils/config_manager.py

@@ -1,13 +1,8 @@
-import os.path
-from os import PathLike
 from threading import Lock
 
 import tomli
-import tomli_w
-
 from pilgrim.utils import DirectoryManager
 
-
 class SingletonMeta(type):
     _instances = {}
     _lock: Lock = Lock()
@@ -19,18 +14,14 @@ class SingletonMeta(type):
                 cls._instances[cls] = instance
         return cls._instances[cls]
 
-
 class ConfigManager(metaclass=SingletonMeta):
     def __init__(self):
         self.database_url = None
         self.database_type = None
         self.auto_open_diary = None
         self.auto_open_new_diary = None
-        self.config_dir = DirectoryManager.get_config_directory()
+    @staticmethod
-        self.__data = None
+    def read_config():
-
-    def read_config(self):
-        if os.path.exists(f"{DirectoryManager.get_config_directory()}/config.toml"):
         try:
             with open(f"{DirectoryManager.get_config_directory()}/config.toml", "rb") as f:
                 data = tomli.load(f)
@@ -40,57 +31,5 @@ class ConfigManager(metaclass=SingletonMeta):
         except tomli.TOMLDecodeError as e:
             print(f"Error decoding TOML: {e}")
 
-            self.__data = data
+    def set_database_url(self):
-            self.database_url = self.__data["database"]["url"]
+        pass
-            self.database_type = self.__data["database"]["type"]
-
-            if self.__data["settings"]["diary"]["auto_open_diary_on_startup"] == "":
-                self.auto_open_diary = None
-            self.auto_open_new_diary = self.__data["settings"]["diary"]["auto_open_on_creation"]
-        else:
-            print("Error: config.toml not found.")
-            self.create_config()
-            self.read_config()
-
-    def create_config(self, config: dict = None):
-        default = {
-            "database": {
-                "url": f"{DirectoryManager.get_config_directory()}/database.db",
-                "type": "sqlite"
-            },
-            "settings": {
-                "diary": {
-                    "auto_open_diary_on_startup": "",
-                    "auto_open_on_creation": False
-                }
-            }
-        }
-        if config is None:
-            config = default
-        try:
-            with open(f"{DirectoryManager.get_config_directory()}/config.toml", "wb") as f:
-                tomli_w.dump(config, f)
-        except FileNotFoundError:
-            print("Error: config.toml not found.")
-
-    def save_config(self):
-        if self.__data is None:
-            self.read_config()
-        self.__data["database"]["url"] = self.database_url
-        self.__data["database"]["type"] = self.database_type
-        self.__data["settings"]["diary"]["auto_open_diary_on_startup"] = self.auto_open_diary or ""
-        self.__data["settings"]["diary"]["auto_open_on_creation"] = self.auto_open_new_diary
-
-        self.create_config(self.__data)
-
-    def set_config_dir(self, value):
-        self.config_dir = value
-
-    def set_database_url(self, value: str):
-        self.database_url = value
-
-    def set_auto_open_diary(self, value: str):
-        self.auto_open_diary = value
-
-    def set_auto_open_new_diary(self, value: bool):
-        self.auto_open_new_diary = value

src/pilgrim/utils/directory_manager.py

@@ -1,5 +1,4 @@
 import os
-import shutil
 from pathlib import Path
 
 
@@ -38,26 +37,3 @@ class DirectoryManager:
     def get_diary_images_directory(directory_name: str) -> Path:
         """Returns the images directory path for a specific diary."""
         return DirectoryManager.get_diary_data_directory(directory_name) / "images"
-
-    @staticmethod
-    def get_database_path() -> Path:
-        """
-        Get the database file path following XDG Base Directory specification.
-        Creates the directory if it doesn't exist.
-        """
-
-        pilgrim_dir = DirectoryManager.get_config_directory()
-        pilgrim_dir.mkdir(exist_ok=True)
-
-        # Database file path
-        db_path = pilgrim_dir / "database.db"
-
-        # If database doesn't exist in new location but exists in current directory,
-        # migrate it
-        if not db_path.exists():
-            current_db = Path("database.db")
-            if current_db.exists():
-                shutil.copy2(current_db, db_path)
-                print(f"Database migrated from {current_db} to {db_path}")
-
-        return db_path