mirror of
https://github.com/clinton-hall/nzbToMedia.git
synced 2025-07-14 17:22:53 -07:00
135 lines
5.6 KiB
Python
135 lines
5.6 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
"""Populate an item's `added` and `mtime` fields by using the file
|
|
modification time (mtime) of the item's source file before import.
|
|
|
|
Reimported albums and items are skipped.
|
|
"""
|
|
from __future__ import division, absolute_import, print_function
|
|
|
|
import os
|
|
|
|
from beets import util
|
|
from beets import importer
|
|
from beets.plugins import BeetsPlugin
|
|
|
|
|
|
class ImportAddedPlugin(BeetsPlugin):
|
|
def __init__(self):
|
|
super(ImportAddedPlugin, self).__init__()
|
|
self.config.add({
|
|
'preserve_mtimes': False,
|
|
'preserve_write_mtimes': False,
|
|
})
|
|
|
|
# item.id for new items that were reimported
|
|
self.reimported_item_ids = None
|
|
# album.path for old albums that were replaced by a reimported album
|
|
self.replaced_album_paths = None
|
|
# item path in the library to the mtime of the source file
|
|
self.item_mtime = dict()
|
|
|
|
register = self.register_listener
|
|
register('import_task_created', self.check_config)
|
|
register('import_task_created', self.record_if_inplace)
|
|
register('import_task_files', self.record_reimported)
|
|
register('before_item_moved', self.record_import_mtime)
|
|
register('item_copied', self.record_import_mtime)
|
|
register('item_linked', self.record_import_mtime)
|
|
register('item_hardlinked', self.record_import_mtime)
|
|
register('album_imported', self.update_album_times)
|
|
register('item_imported', self.update_item_times)
|
|
register('after_write', self.update_after_write_time)
|
|
|
|
def check_config(self, task, session):
|
|
self.config['preserve_mtimes'].get(bool)
|
|
|
|
def reimported_item(self, item):
|
|
return item.id in self.reimported_item_ids
|
|
|
|
def reimported_album(self, album):
|
|
return album.path in self.replaced_album_paths
|
|
|
|
def record_if_inplace(self, task, session):
|
|
if not (session.config['copy'] or session.config['move'] or
|
|
session.config['link'] or session.config['hardlink']):
|
|
self._log.debug(u"In place import detected, recording mtimes from "
|
|
u"source paths")
|
|
items = [task.item] \
|
|
if isinstance(task, importer.SingletonImportTask) \
|
|
else task.items
|
|
for item in items:
|
|
self.record_import_mtime(item, item.path, item.path)
|
|
|
|
def record_reimported(self, task, session):
|
|
self.reimported_item_ids = set(item.id for item, replaced_items
|
|
in task.replaced_items.items()
|
|
if replaced_items)
|
|
self.replaced_album_paths = set(task.replaced_albums.keys())
|
|
|
|
def write_file_mtime(self, path, mtime):
|
|
"""Write the given mtime to the destination path.
|
|
"""
|
|
stat = os.stat(util.syspath(path))
|
|
os.utime(util.syspath(path), (stat.st_atime, mtime))
|
|
|
|
def write_item_mtime(self, item, mtime):
|
|
"""Write the given mtime to an item's `mtime` field and to the mtime
|
|
of the item's file.
|
|
"""
|
|
# The file's mtime on disk must be in sync with the item's mtime
|
|
self.write_file_mtime(util.syspath(item.path), mtime)
|
|
item.mtime = mtime
|
|
|
|
def record_import_mtime(self, item, source, destination):
|
|
"""Record the file mtime of an item's path before its import.
|
|
"""
|
|
mtime = os.stat(util.syspath(source)).st_mtime
|
|
self.item_mtime[destination] = mtime
|
|
self._log.debug(u"Recorded mtime {0} for item '{1}' imported from "
|
|
u"'{2}'", mtime, util.displayable_path(destination),
|
|
util.displayable_path(source))
|
|
|
|
def update_album_times(self, lib, album):
|
|
if self.reimported_album(album):
|
|
self._log.debug(u"Album '{0}' is reimported, skipping import of "
|
|
u"added dates for the album and its items.",
|
|
util.displayable_path(album.path))
|
|
return
|
|
|
|
album_mtimes = []
|
|
for item in album.items():
|
|
mtime = self.item_mtime.pop(item.path, None)
|
|
if mtime:
|
|
album_mtimes.append(mtime)
|
|
if self.config['preserve_mtimes'].get(bool):
|
|
self.write_item_mtime(item, mtime)
|
|
item.store()
|
|
album.added = min(album_mtimes)
|
|
self._log.debug(u"Import of album '{0}', selected album.added={1} "
|
|
u"from item file mtimes.", album.album, album.added)
|
|
album.store()
|
|
|
|
def update_item_times(self, lib, item):
|
|
if self.reimported_item(item):
|
|
self._log.debug(u"Item '{0}' is reimported, skipping import of "
|
|
u"added date.", util.displayable_path(item.path))
|
|
return
|
|
mtime = self.item_mtime.pop(item.path, None)
|
|
if mtime:
|
|
item.added = mtime
|
|
if self.config['preserve_mtimes'].get(bool):
|
|
self.write_item_mtime(item, mtime)
|
|
self._log.debug(u"Import of item '{0}', selected item.added={1}",
|
|
util.displayable_path(item.path), item.added)
|
|
item.store()
|
|
|
|
def update_after_write_time(self, item):
|
|
"""Update the mtime of the item's file with the item.added value
|
|
after each write of the item if `preserve_write_mtimes` is enabled.
|
|
"""
|
|
if item.added:
|
|
if self.config['preserve_write_mtimes'].get(bool):
|
|
self.write_item_mtime(item, item.added)
|
|
self._log.debug(u"Write of item '{0}', selected item.added={1}",
|
|
util.displayable_path(item.path), item.added)
|