ctactic/aircox-radiocampus
1
0
Fork 0
forked from rc/aircox
Code Issues 10 Pull Requests Activity

work hard on this

Browse Source
This commit is contained in:
bkfox
2019-06-29 18:13:25 +02:00
parent a951d7a319
commit 74dbc620ed
31 changed files with 1191 additions and 833 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
aircox/management/commands/import_playlist.py
View File

@ -29,62 +29,65 @@ class Importer:
path = None
data = None
tracks = None
track_kwargs = {}
def __init__(self, related = None, path = None, save = False):
if path:
self.read(path)
if related:
self.make_playlist(related, save)
def __init__(self, path=None, **track_kwargs):
self.path = path
self.track_kwargs = track_kwargs
def reset(self):
self.data = None
self.tracks = None
def read(self, path):
if not os.path.exists(path):
def run(self):
self.read()
if self.track_kwargs.get('sound') is not None:
self.make_playlist()
def read(self):
if not os.path.exists(self.path):
return True
with open(path, 'r') as file:
logger.info('start reading csv ' + path)
self.path = path
with open(self.path, 'r') as file:
logger.info('start reading csv ' + self.path)
self.data = list(csv.DictReader(
(row for row in file
if not (row.startswith('#') or row.startswith('\ufeff#'))
and row.strip()
),
fieldnames = settings.AIRCOX_IMPORT_PLAYLIST_CSV_COLS,
delimiter = settings.AIRCOX_IMPORT_PLAYLIST_CSV_DELIMITER,
quotechar = settings.AIRCOX_IMPORT_PLAYLIST_CSV_TEXT_QUOTE,
and row.strip()),
fieldnames=settings.AIRCOX_IMPORT_PLAYLIST_CSV_COLS,
delimiter=settings.AIRCOX_IMPORT_PLAYLIST_CSV_DELIMITER,
quotechar=settings.AIRCOX_IMPORT_PLAYLIST_CSV_TEXT_QUOTE,
))
def make_playlist(self, related, save = False):
def make_playlist(self):
"""
Make a playlist from the read data, and return it. If save is
true, save it into the database
"""
if self.track_kwargs.get('sound') is None:
logger.error('related track\'s sound is missing. Skip import of ' +
self.path + '.')
return
maps = settings.AIRCOX_IMPORT_PLAYLIST_CSV_COLS
tracks = []
logger.info('parse csv file ' + self.path)
in_seconds = ('minutes' or 'seconds') in maps
has_timestamp = ('minutes' or 'seconds') in maps
for index, line in enumerate(self.data):
if ('title' or 'artist') not in line:
return
try:
position = \
int(line.get('minutes') or 0) * 60 + \
int(line.get('seconds') or 0) \
if in_seconds else index
timestamp = int(line.get('minutes') or 0) * 60 + \
int(line.get('seconds') or 0) \
if has_timestamp else None
track, created = Track.objects.get_or_create(
related_type = ContentType.objects.get_for_model(related),
related_id = related.pk,
title = line.get('title'),
artist = line.get('artist'),
position = position,
title=line.get('title'),
artist=line.get('artist'),
position=index,
**self.track_kwargs
)
track.in_seconds = in_seconds
track.timestamp = timestamp
track.info = line.get('info')
tags = line.get('tags')
if tags:
@ -97,8 +100,7 @@ class Importer:
)
continue
if save:
track.save()
track.save()
tracks.append(track)
self.tracks = tracks
return tracks
@ -107,10 +109,8 @@ class Importer:
class Command (BaseCommand):
help= __doc__
def add_arguments (self, parser):
def add_arguments(self, parser):
parser.formatter_class=RawTextHelpFormatter
now = tz.datetime.today()
parser.add_argument(
'path', metavar='PATH', type=str,
help='path of the input playlist to read'
@ -128,27 +128,24 @@ class Command (BaseCommand):
def handle (self, path, *args, **options):
# FIXME: absolute/relative path of sounds vs given path
if options.get('sound'):
related = Sound.objects.filter(
path__icontains = options.get('sound')
sound = Sound.objects.filter(
path__icontains=options.get('sound')
).first()
else:
path_, ext = os.path.splitext(path)
related = Sound.objects.filter(path__icontains = path_).first()
sound = Sound.objects.filter(path__icontains=path_).first()
if not related:
if not sound:
logger.error('no sound found in the database for the path ' \
'{path}'.format(path=path))
return
if options.get('diffusion') and related.diffusion:
related = related.diffusion
if options.get('diffusion') and sound.diffusion:
sound = sound.diffusion
importer = Importer(related = related, path = path, save = True)
importer = Importer(path, sound=sound).run()
for track in importer.tracks:
logger.info('imported track at {pos}: {title}, by '
'{artist}'.format(
pos = track.position,
title = track.title, artist = track.artist
)
)
logger.info('track #{pos} imported: {title}, by {artist}'.format(
pos=track.position, title=track.title, artist=track.artist
))

93
aircox/management/commands/sounds_monitor.py
View File

@ -43,6 +43,7 @@ import aircox.utils as utils
logger = logging.getLogger('aircox.tools')
class SoundInfo:
name = ''
sound = None
@ -76,7 +77,7 @@ class SoundInfo:
file_name)
if not (r and r.groupdict()):
r = { 'name': file_name }
r = {'name': file_name}
logger.info('file name can not be parsed -> %s', value)
else:
r = r.groupdict()
@ -93,7 +94,7 @@ class SoundInfo:
self.n = r.get('n')
return r
def __init__(self, path = '', sound = None):
def __init__(self, path='', sound=None):
self.path = path
self.sound = sound
@ -107,7 +108,7 @@ class SoundInfo:
self.duration = duration
return duration
def get_sound(self, save = True, **kwargs):
def get_sound(self, save=True, **kwargs):
"""
Get or create a sound using self info.
@ -115,8 +116,8 @@ class SoundInfo:
(if save is True, sync to DB), and check for a playlist file.
"""
sound, created = Sound.objects.get_or_create(
path = self.path,
defaults = kwargs
path=self.path,
defaults=kwargs
)
if created or sound.check_on_file():
logger.info('sound is new or have been modified -> %s', self.path)
@ -127,7 +128,7 @@ class SoundInfo:
self.sound = sound
return sound
def find_playlist(self, sound, use_default = True):
def find_playlist(self, sound, use_default=True):
"""
Find a playlist file corresponding to the sound path, such as:
my_sound.ogg => my_sound.csv
@ -135,11 +136,11 @@ class SoundInfo:
If use_default is True and there is no playlist find found,
use sound file's metadata.
"""
if sound.tracks.count():
if sound.track_set.count():
return
import aircox.management.commands.import_playlist \
as import_playlist
as import_playlist
# no playlist, try to retrieve metadata
path = os.path.splitext(self.sound.path)[0] + '.csv'
@ -151,9 +152,9 @@ class SoundInfo:
return
# else, import
import_playlist.Importer(sound, path, save=True)
import_playlist.Importer(path, sound=sound).run()
def find_diffusion(self, program, save = True):
def find_diffusion(self, program, save=True):
"""
For a given program, check if there is an initial diffusion
to associate to, using the date info we have. Update self.sound
@ -163,7 +164,7 @@ class SoundInfo:
rerun.
"""
if self.year == None or not self.sound or self.sound.diffusion:
return;
return
if self.hour is None:
date = datetime.date(self.year, self.month, self.day)
@ -173,7 +174,7 @@ class SoundInfo:
date = tz.get_current_timezone().localize(date)
qs = Diffusion.objects.station(program.station).after(date) \
.filter(program = program, initial__isnull = True)
.filter(program=program, initial__isnull=True)
diffusion = qs.first()
if not diffusion:
return
@ -190,18 +191,19 @@ class MonitorHandler(PatternMatchingEventHandler):
"""
Event handler for watchdog, in order to be used in monitoring.
"""
def __init__(self, subdir):
"""
subdir: AIRCOX_SOUND_ARCHIVES_SUBDIR or AIRCOX_SOUND_EXCERPTS_SUBDIR
"""
self.subdir = subdir
if self.subdir == settings.AIRCOX_SOUND_ARCHIVES_SUBDIR:
self.sound_kwargs = { 'type': Sound.Type.archive }
self.sound_kwargs = {'type': Sound.Type.archive}
else:
self.sound_kwargs = { 'type': Sound.Type.excerpt }
self.sound_kwargs = {'type': Sound.Type.excerpt}
patterns = ['*/{}/*{}'.format(self.subdir, ext)
for ext in settings.AIRCOX_SOUND_FILE_EXT ]
for ext in settings.AIRCOX_SOUND_FILE_EXT]
super().__init__(patterns=patterns, ignore_directories=True)
def on_created(self, event):
@ -215,14 +217,14 @@ class MonitorHandler(PatternMatchingEventHandler):
si = SoundInfo(event.src_path)
self.sound_kwargs['program'] = program
si.get_sound(save = True, **self.sound_kwargs)
si.get_sound(save=True, **self.sound_kwargs)
if si.year is not None:
si.find_diffusion(program)
si.sound.save(True)
def on_deleted(self, event):
logger.info('sound deleted: %s', event.src_path)
sound = Sound.objects.filter(path = event.src_path)
sound = Sound.objects.filter(path=event.src_path)
if sound:
sound = sound[0]
sound.type = sound.Type.removed
@ -230,7 +232,7 @@ class MonitorHandler(PatternMatchingEventHandler):
def on_moved(self, event):
logger.info('sound moved: %s -> %s', event.src_path, event.dest_path)
sound = Sound.objects.filter(path = event.src_path)
sound = Sound.objects.filter(path=event.src_path)
if not sound:
self.on_modified(
FileModifiedEvent(event.dest_path)
@ -242,18 +244,19 @@ class MonitorHandler(PatternMatchingEventHandler):
if not sound.diffusion:
program = Program.get_from_path(event.src_path)
if program:
si = SoundInfo(sound.path, sound = sound)
si = SoundInfo(sound.path, sound=sound)
if si.year is not None:
si.find_diffusion(program)
sound.save()
class Command(BaseCommand):
help= __doc__
help = __doc__
def report(self, program = None, component = None, *content):
def report(self, program=None, component=None, *content):
if not component:
logger.info('%s: %s', str(program), ' '.join([str(c) for c in content]))
logger.info('%s: %s', str(program),
' '.join([str(c) for c in content]))
else:
logger.info('%s, %s: %s', str(program), str(component),
' '.join([str(c) for c in content]))
@ -270,11 +273,11 @@ class Command(BaseCommand):
logger.info('#%d %s', program.id, program.name)
self.scan_for_program(
program, settings.AIRCOX_SOUND_ARCHIVES_SUBDIR,
type = Sound.Type.archive,
type=Sound.Type.archive,
)
self.scan_for_program(
program, settings.AIRCOX_SOUND_EXCERPTS_SUBDIR,
type = Sound.Type.excerpt,
type=Sound.Type.excerpt,
)
dirs.append(os.path.join(program.path))
@ -300,14 +303,14 @@ class Command(BaseCommand):
si = SoundInfo(path)
sound_kwargs['program'] = program
si.get_sound(save = True, **sound_kwargs)
si.find_diffusion(program, save = True)
si.get_sound(save=True, **sound_kwargs)
si.find_diffusion(program, save=True)
si.find_playlist(si.sound)
sounds.append(si.sound.pk)
# sounds in db & unchecked
sounds = Sound.objects.filter(path__startswith = subdir). \
exclude(pk__in = sounds)
sounds = Sound.objects.filter(path__startswith=subdir). \
exclude(pk__in=sounds)
self.check_sounds(sounds)
@staticmethod
@ -318,18 +321,18 @@ class Command(BaseCommand):
# check files
for sound in qs:
if sound.check_on_file():
sound.save(check = False)
sound.save(check=False)
def check_quality(self, check = False):
def check_quality(self, check=False):
"""
Check all files where quality has been set to bad
"""
import aircox.management.commands.sounds_quality_check \
as quality_check
as quality_check
# get available sound files
sounds = Sound.objects.filter(good_quality = False) \
.exclude(type = Sound.Type.removed)
sounds = Sound.objects.filter(good_quality=False) \
.exclude(type=Sound.Type.removed)
if check:
self.check_sounds(sounds)
@ -341,11 +344,12 @@ class Command(BaseCommand):
# check quality
logger.info('quality check...',)
cmd = quality_check.Command()
cmd.handle( files = files,
**settings.AIRCOX_SOUND_QUALITY )
cmd.handle(files=files,
**settings.AIRCOX_SOUND_QUALITY)
# update stats
logger.info('update stats in database')
def update_stats(sound_info, sound):
stats = sound_info.get_file_stats()
if stats:
@ -353,25 +357,25 @@ class Command(BaseCommand):
sound.duration = utils.seconds_to_time(duration)
for sound_info in cmd.good:
sound = Sound.objects.get(path = sound_info.path)
sound = Sound.objects.get(path=sound_info.path)
sound.good_quality = True
update_stats(sound_info, sound)
sound.save(check = False)
sound.save(check=False)
for sound_info in cmd.bad:
sound = Sound.objects.get(path = sound_info.path)
sound = Sound.objects.get(path=sound_info.path)
update_stats(sound_info, sound)
sound.save(check = False)
sound.save(check=False)
def monitor(self):
"""
Run in monitor mode
"""
archives_handler = MonitorHandler(
subdir = settings.AIRCOX_SOUND_ARCHIVES_SUBDIR
subdir=settings.AIRCOX_SOUND_ARCHIVES_SUBDIR
)
excerpts_handler = MonitorHandler(
subdir = settings.AIRCOX_SOUND_EXCERPTS_SUBDIR
subdir=settings.AIRCOX_SOUND_EXCERPTS_SUBDIR
)
observer = Observer()
@ -390,10 +394,10 @@ class Command(BaseCommand):
time.sleep(1)
def add_arguments(self, parser):
parser.formatter_class=RawTextHelpFormatter
parser.formatter_class = RawTextHelpFormatter
parser.add_argument(
'-q', '--quality_check', action='store_true',
help='Enable quality check using sound_quality_check on all ' \
help='Enable quality check using sound_quality_check on all '
'sounds marqued as not good'
)
parser.add_argument(
@ -411,7 +415,6 @@ class Command(BaseCommand):
if options.get('scan'):
self.scan()
if options.get('quality_check'):
self.check_quality(check = (not options.get('scan')) )
self.check_quality(check=(not options.get('scan')))
if options.get('monitor'):
self.monitor()

44
aircox/management/commands/streamer.py
View File

@ -82,17 +82,14 @@ class Monitor:
"""
Last sound log of monitored station that occurred on_air
"""
return self.get_last_log(type = Log.Type.on_air,
sound__isnull = False)
return self.get_last_log(type=Log.Type.on_air, sound__isnull=False)
@property
def last_diff_start(self):
"""
Log of last triggered item (sound or diffusion)
"""
return self.get_last_log(type = Log.Type.start,
diffusion__isnull = False)
return self.get_last_log(type=Log.Type.start, diffusion__isnull=False)
def __init__(self, station, **kwargs):
self.station = station
@ -120,12 +117,11 @@ class Monitor:
self.sync_playlists()
self.handle()
def log(self, date = None, **kwargs):
def log(self, date=None, **kwargs):
"""
Create a log using **kwargs, and print info
"""
log = Log(station = self.station, date = date or tz.now(),
**kwargs)
log = Log(station=self.station, date=date or tz.now(), **kwargs)
log.save()
log.print()
return log
@ -142,14 +138,14 @@ class Monitor:
air_times = (air_time - delta, air_time + delta)
log = self.log_qs.on_air().filter(
source = source.id, sound__path = sound_path,
date__range = air_times,
source=source.id, sound__path=sound_path,
date__range=air_times,
).last()
if log:
return log
# get sound
sound = Sound.objects.filter(path = sound_path) \
sound = Sound.objects.filter(path=sound_path) \
.select_related('diffusion').first()
diff = None
if sound and sound.diffusion:
@ -157,20 +153,16 @@ class Monitor:
# check for reruns
if not diff.is_date_in_range(air_time) and not diff.initial:
diff = Diffusion.objects.at(air_time) \
.filter(initial = diff).first()
.filter(initial=diff).first()
# log sound on air
return self.log(
type = Log.Type.on_air,
source = source.id,
date = source.on_air,
sound = sound,
diffusion = diff,
type=Log.Type.on_air, source=source.id, date=source.on_air,
sound=sound, diffusion=diff,
# if sound is removed, we keep sound path info
comment = sound_path,
comment=sound_path,
)
def trace_tracks(self, log):
"""
Log tracks for the given sound log (for streamed programs only).
@ -178,23 +170,21 @@ class Monitor:
if log.diffusion:
return
tracks = Track.objects.related(object = log.sound) \
.filter(in_seconds = True)
tracks = Track.objects.filter(sound=log.sound, timestamp_isnull=False)
if not tracks.exists():
return
tracks = tracks.exclude(log__station = self.station,
log__pk__gt = log.pk)
tracks = tracks.exclude(log__station=self.station, log__pk__gt=log.pk)
now = tz.now()
for track in tracks:
pos = log.date + tz.timedelta(seconds = track.position)
pos = log.date + tz.timedelta(seconds=track.position)
if pos > now:
break
# log track on air
self.log(
type = Log.Type.on_air, source = log.source,
date = pos, track = track,
comment = track,
type=Log.Type.on_air, source=log.source,
date=pos, track=track,
comment=track,
)
def sync_playlists(self):