def __init__(self):
super(UserRatingsPlugin, self).__init__()
self.config.add({
# Should we automatically import any values we find?
'auto': True,
# Should we overwrite an existing entry?
'overwrite': False,
# Should we sync others player ratings when updating a rating
'sync_ratings': True,
# SHould we save ratings to a playlist file? (Android Poweramp)
'ratings_file': "",
'forward_slash': False
})
# Add importing ratings to the import process
if self.config['auto']:
self.import_stages = [self.imported]
# Given the complexity of the storage style implementations, I
# find it handy to allow them to do unified logging.
userrating_field = mediafile.MediaField(
AmarokRatingStorageStyle(_log=self._log, _is_external=False),
MP3UserRatingStorageStyle(_log=self._log, _is_external=False),
UserRatingStorageStyle(_log=self._log, _is_external=False),
ASFRatingStorageStyle(_log=self._log, _is_external=False),
DefaultValueStorageStyle(_log=self._log, _is_external=True),
out_type=int)
externalrating_field = mediafile.MediaField(
AmarokRatingStorageStyle(_log=self._log, _is_external=True),
MP3UserRatingStorageStyle(_log=self._log, _is_external=True),
UserRatingStorageStyle(_log=self._log, _is_external=True),
ASFRatingStorageStyle(_log=self._log, _is_external=True),
DefaultValueStorageStyle(_log=self._log, _is_external=True),
out_type=int)
if 'userrating' not in mediafile.MediaFile.__dict__:
self.add_media_field('userrating', userrating_field)
# this is only to be able to import existing value to beet userrating
# and export/sync updated values.
if 'externalrating' not in mediafile.MediaFile.__dict__:
self.add_media_field('externalrating', externalrating_field)
if self.config['ratings_file'].get():
self.register_listener(
"database_change",
lambda lib, model: self.register_write_listener())
def __init__(self, *args, **kwargs):
super(CanonicalPlugin, self).__init__(*args, **kwargs)
self.config.add({
'artist_credit': False,
'albumartist_credit': False,
'original_date': False,
'album_disambig': False
})
self.register_listener('album_imported', self.album_imported)
self.register_listener('write', self.write)
for field in self.artists_fields:
canonical = field + u'_canonical'
canonical_desc = ' '.join(s.capitalize()
for s in canonical.split(u'_'))
media_field = mediafile.MediaField(
mediafile.MP3DescStorageStyle(canonical_desc),
mediafile.MP4StorageStyle(
u"----:com.apple.iTunes:{}".format(canonical_desc)),
mediafile.StorageStyle(canonical.upper()),
mediafile.ASFStorageStyle('beets/{}'.format(canonical_desc)),
)
self.add_media_field(canonical, media_field)
date_canonical = mediafile.DateField(
mediafile.MP3DescStorageStyle(u'Date Canonical'),
mediafile.MP4StorageStyle('----:com.apple.iTunes:Date Canonical'),
mediafile.StorageStyle('DATE_CANONICAL'),
mediafile.ASFStorageStyle('WM/Date Canonical'))
for df in ('year', 'month', 'day'):
self.add_media_field(
'{}_canonical'.format(df),
getattr(date_canonical, '{}_field'.format(df))())
def __init__(self, *args, **kwargs):
album_sort_field = mediafile.MediaField(
mediafile.MP3StorageStyle(u"TSOA"),
mediafile.MP4StorageStyle(u"soal"),
mediafile.StorageStyle(u"Album Sort")
)
self.add_media_field("album_sort", album_sort_field)
self.register_listener("write", self.write)
super().__init__(*args, **kwargs)
def setUp(self):
self.create_temp_dir()
self.key = "READ_ONLY_TEST"
self.field = mediafile.MediaField(
mediafile.MP3StorageStyle(self.key, read_only=True),
mediafile.MP4StorageStyle("----:com.apple.iTunes:" + self.key,
read_only=True),
mediafile.StorageStyle(self.key, read_only=True),
mediafile.ASFStorageStyle(self.key, read_only=True),
)
if "read_only_test" not in mediafile.MediaFile.fields():
mediafile.MediaFile.add_field("read_only_test", self.field)
def __init__(self):
super(iTunesAdvisoryPlugin, self).__init__()
self.config.add({
'auto': True,
})
field = mediafile.MediaField(
mediafile.MP3DescStorageStyle(u'ITUNESADVISORY'),
mediafile.MP4StorageStyle(u'rtng'),
mediafile.StorageStyle(u'ITUNESADVISORY'),
mediafile.ASFStorageStyle(u'ITUNESADVISORY'),
out_type=int,
)
mediafile.MediaFile.add_field('itunesadvisory', field)
if self.config['auto'].get():
self.import_stages = [self.imported]
def __init__(self):
super(GoingRunningPlugin, self).__init__()
# Read default configuration
config_file_path = os.path.join(os.path.dirname(__file__),
self._default_plugin_config_file_name_)
source = ConfigSource(load_yaml(config_file_path) or {},
config_file_path)
self.config.add(source)
# Add `play_count` field support
fld_name = u'play_count'
if fld_name not in mediafile.MediaFile.fields():
field = mediafile.MediaField(
mediafile.MP3DescStorageStyle(fld_name),
mediafile.StorageStyle(fld_name),
out_type=int
)
self.add_media_field(fld_name, field)
def __init__(self):
super(OldestDatePlugin, self).__init__()
self.import_stages = [self._on_import]
self.config.add({
'auto': True, # Run during import phase
'ignore_track_id': False, # During import, ignore existing track_id
'filter_on_import': True, # During import, weight down candidates with no work_id
'prompt_missing_work_id': True, # During import, prompt to fix work_id if missing
'force': False, # Run even if already processed
'overwrite_year': False, # Overwrite year field in tags
'filter_recordings': True, # Skip recordings with attributes before fetching them
'approach': 'releases', # recordings, releases, hybrid, both
'release_types': None, # Filter by release type, e.g. ['Official']
'use_file_date': False # Also use file's embedded date when looking for oldest date
})
if self.config['ignore_track_id']:
self.register_listener('import_task_created', self._import_task_created)
if self.config['prompt_missing_work_id']:
self.register_listener('import_task_choice', self._import_task_choice)
if self.config['filter_on_import']:
self.register_listener('trackinfo_received', self._import_trackinfo)
# Add heavy weight for missing work_id from a track
config['match']['distance_weights'].add({'work_id': 4})
# Get global MusicBrainz host setting
musicbrainzngs.set_hostname(config['musicbrainz']['host'].get())
musicbrainzngs.set_rate_limit(1, config['musicbrainz']['ratelimit'].get())
for recording_field in (
'recording_year',
'recording_month',
'recording_day',
'recording_disambiguation'):
field = mediafile.MediaField(
mediafile.MP3DescStorageStyle(recording_field),
mediafile.MP4StorageStyle('----:com.apple.iTunes:{}'.format(
recording_field)),
mediafile.StorageStyle(recording_field))
self.add_media_field(recording_field, field)
def test_overwrite_property(self):
with self.assertRaises(ValueError) as cm:
mediafile.MediaFile.add_field('artist', mediafile.MediaField())
self.assertIn(u'property "artist" already exists',
six.text_type(cm.exception))
from __future__ import division, absolute_import, print_function
import os
import six
import shutil
import unittest
from test import _common
from beets.library import Item
import mediafile
from beets.plugins import BeetsPlugin
from beets.util import bytestring_path
field_extension = mediafile.MediaField(
mediafile.MP3DescStorageStyle(u'customtag'),
mediafile.MP4StorageStyle('----:com.apple.iTunes:customtag'),
mediafile.StorageStyle('customtag'),
mediafile.ASFStorageStyle('customtag'),
)
class ExtendedFieldTestMixin(_common.TestCase):
def _mediafile_fixture(self, name, extension='mp3'):
name = bytestring_path(name + '.' + extension)
src = os.path.join(_common.RSRC, name)
target = os.path.join(self.temp_dir, name)
shutil.copy(src, target)
return mediafile.MediaFile(target)
def test_extended_field_write(self):
plugin = BeetsPlugin()
plugin.add_media_field('customtag', field_extension)
