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")
