def mock_gtk_version(tmp_path, monkeypatch): """Fixture to mock the xdg directories and fill them with gtk-version-like files.""" for name in ("cache", "config", "data"): directory = tmp_path / name directory.mkdir() monkeypatch.setenv(f"XDG_{name.upper()}_HOME", str(directory)) for directory in ( xdg.vimiv_config_dir(), xdg.vimiv_cache_dir(), xdg.vimiv_data_dir(), ): assert "home" not in directory, "patching the xdg directories failed" os.makedirs(directory) for basename in ("vimivrc", "keys.conf"): abspath = xdg.vimiv_config_dir(basename) with open(abspath, "w") as f: f.write("option: value\n") tag_dir = xdg.vimiv_data_dir("Tags") os.mkdir(tag_dir) tag_file = os.path.join(tag_dir, TAGFILE_NAME) with open(tag_file, "w") as f: for i in range(10): f.write(f"test_{i:02d}.jpg\n") yield migration.WelcomePopUp.gtk_installed = False
def setup_logging(level: int, *debug_modules: str) -> None: """Configure and set up logging. There are two types of loggers: the application-wide logger accessible through the convenience functions and the module-level loggers. Both loggers write to stderr and $XDG_DATA_HOME/vimiv/vimiv.log. The application-wide logger sends messages with a level higher than debug to the statusbar in addition. No logging should be performed in this function as the logging header comes directly after it. Args: level: Integer log level set for the console handler. debug_modules: Module names for which debug messages are forced to be shown. """ # Enable logging at debug level in general logging.getLogger().setLevel(logging.DEBUG) # Configure handlers console_handler = logging.StreamHandler() console_handler.setFormatter(formatter) # mode=w creates a new file for every new vimiv process file_handler = logging.FileHandler(xdg.vimiv_data_dir("vimiv.log"), mode="w") file_handler.setFormatter(formatter) # Configure app logger _app_logger.level = level _app_logger.handlers = [file_handler, console_handler, statusbar_loghandler] LazyLogger.handlers = [console_handler, file_handler] # Setup debug logging for specific module loggers _debug_loggers.extend(debug_modules) for name, logger in _module_loggers.items(): logger.level = logging.DEBUG if name in debug_modules else level
def migrate_tags(gtk_data_dir: str) -> None: """Migrate gtk tag file to the new path. Args: gtk_data_dir: Path to the old gtk data directory. """ gtk_tagdir = os.path.join(gtk_data_dir, "Tags") if os.path.isdir(gtk_tagdir): shutil.copytree(gtk_tagdir, xdg.vimiv_data_dir("tags")) print("... Moved tag directory")
def init_directories(args: argparse.Namespace) -> None: """Create vimiv cache, config and data directories. The directories are either the directories defined in the freedesktop standard or located in a temporary base directory. Args: args: Arguments returned from parser.parse_args(). """ if args.temp_basedir: global _tmpdir _tmpdir = tempfile.TemporaryDirectory(prefix="vimiv-tempdir-") args.basedir = _tmpdir.name if args.basedir is not None: xdg.basedir = args.basedir xdg.makedirs(xdg.vimiv_cache_dir(), xdg.vimiv_config_dir(), xdg.vimiv_data_dir())
def backup() -> XdgDirectories: """Create a backup of all gtk vimiv directories.""" backup_str = "-gtk-backup" backup_dirs: List[Optional[str]] = [] for dirname in ( xdg.vimiv_cache_dir(), xdg.vimiv_config_dir(), xdg.vimiv_data_dir(), ): try: backup_dirname = dirname + backup_str shutil.move(dirname, backup_dirname) print(f"... Created backup of '{dirname}' at '{backup_dirname}'") backup_dirs.append(backup_dirname) except OSError as e: print(f"... Error backing up {dirname}: {e}") backup_dirs.append(None) return XdgDirectories(*backup_dirs)
def init_directories(args): """Create vimiv cache, config and data directories. The directories are either the directories defined in the freedesktop standard or located in a temporary base directory. Args: args: Arguments returned from parser.parse_args(). """ if args.temp_basedir: global _tmpdir _tmpdir = tempfile.TemporaryDirectory(prefix="vimiv-tempdir-") basedir = _tmpdir.name os.environ["XDG_CACHE_HOME"] = os.path.join(basedir, "cache") os.environ["XDG_CONFIG_HOME"] = os.path.join(basedir, "config") os.environ["XDG_DATA_HOME"] = os.path.join(basedir, "data") for directory in [ xdg.vimiv_cache_dir(), xdg.vimiv_config_dir(), xdg.vimiv_data_dir(), xdg.join_vimiv_config("styles"), ]: os.makedirs(directory, exist_ok=True)
def dirname() -> str: """Return path to the tag directory.""" return xdg.vimiv_data_dir("tags")
_user_plugin_directory: Directory in which user-installed plugins are located. _plugins: Dictionary mapping plugin names to additional information as defined in the configuration file. _loaded_plugins: Dictionary mapping loaded plugin names to the loaded python module. """ import importlib import os import sys import types from typing import Dict, List from vimiv.utils import xdg, log, quotedjoin _app_plugin_directory = os.path.dirname(__file__) _user_plugin_directory = xdg.vimiv_data_dir("plugins") _plugins: Dict[str, str] = { "print": "default" } # key: name, value: additional information _loaded_plugins: Dict[str, types.ModuleType] = {} # key:name, value: loaded module _logger = log.module_logger(__name__) def load() -> None: """Load plugins defined. If no plugins are passed to the function all active plugins are loaded. Args: plugins: Plugin names to load.
def test_migrate_tags(mock_gtk_version): migration.migrate_tags(xdg.vimiv_data_dir()) assert os.path.isdir(xdg.vimiv_data_dir("tags")) assert os.path.isfile(xdg.vimiv_data_dir("tags", TAGFILE_NAME))
def filename(cls): """Return absolute path to a history file.""" return xdg.vimiv_data_dir("history.json")
def filename() -> str: """Return absolute path to history file.""" return xdg.vimiv_data_dir("history")