#!bin/python

import run_local  # noqa

import light9.networking

import tkinter as tk

from light9.ascoltami.musictime_client import MusicTime

mt = MusicTime()

class MusicTimeTk(tk.Frame, MusicTime):

    def __init__(self, master, url):

        tk.Frame.__init__(self)

        MusicTime.__init__(self, url)

        self.timevar = tk.DoubleVar()

            print(self.timevar.get(), evt.keysym)

        self.timelabel.bind('<KeyPress>', print_time)

        self.timelabel.bind('<1>', print_time)

        self.timelabel.focus()

        task.LoopingCall(self.update_time).start(.1)

    def update_time(self):

        t = self.getLatest().get('t', 0)

        self.timevar.set(t)

if __name__ == "__main__":

    from optparse import OptionParser

    parser = OptionParser()

    parser.add_option("-u", "--url", default=light9.networking.musicPlayer.url)

    options, args = parser.parse_args()

    root = tk.Tk()

    root.title("Time")

    MusicTimeTk(root, options.url).pack(expand=1, fill='both')

    tksupport.install(root, ms=20)

    reactor.run()

            traceback.print_exc()

            raise

pipeline = videorecorder.GstSource(

    '/dev/v4l/by-id/usb-Bison_HD_Webcam_200901010001-video-index0'

)

class Live(cyclone.websocket.WebSocketHandler):

    def connectionMade(self, *args, **kwargs):

    """

    def __init__(self,

                 period=.2,

                 onChange=lambda position: None,

                 pollCurvecalc='ignored'):

        We call onChange with the time in seconds and the total time

        The choice of period doesn't need to be tied to framerate,

        it's more the size of the error you can tolerate (since we

        make up times between the samples, and we'll just run off the

import time, logging, os, traceback, sys

import gi

gi.require_version('Gst', '1.0')

gi.require_version('GstBase', '1.0')

from gi.repository import Gst

from rx.subjects import BehaviorSubject

from twisted.internet import defer, threads

import moviepy.editor

import numpy

from light9.ascoltami.musictime_client import MusicTime

from light9.newtypes import Song

from IPython.core import ultratb

sys.excepthook = ultratb.FormattedTB(mode='Verbose',

                                     color_scheme='Linux',

                                     call_pdb=1)

log = logging.getLogger()

@dataclass(frozen=True)

class CaptureFrame:

    img: Image

    song: Song

    t: float

    isPlaying: bool

class FramesToVideoFiles:

    """

    nextWriteAction: 'ignore'

    currentOutputClip: None

    (music stops or song changes)

    nextWriteAction: 'close'

    currentOutputClip: None

    nextWriteAction: 'ignore'

    """

    def __init__(self, frames: BehaviorSubject):

        self.frames = frames

        self.currentOutputClip = None

        self.nextWriteAction = 'ignore'

        self.frames.subscribe(on_next=self.onFrame)

    def onFrame(self, cf: Optional[CaptureFrame]):

        if cf is None:

            return

            self.currentOutputSong = cf.song

            self.save('/tmp/out%s' % time.time())

        elif self.currentOutputClip and cf.isPlaying:

            self.nextWriteAction = 'saveFrames'

            # continue recording this

        elif self.currentOutputClip is None and not cf.isPlaying:

        elif self.currentOutputClip and not cf.isPlaying or self.currentOutputSong != cf.song:

            # stop

            self.nextWriteAction = 'close'

        else:

    def save(self, outBase):

        """

        receive frames (infinite) and wall-to-song times (stream ends with

        the song), and write a video file and a frame map

        """

        # (immediately calls make_frame)

        self.currentOutputClip = moviepy.editor.VideoClip(

            self._bg_make_frame, duration=999.)

        self.currentOutputClip.fps = 5

        log.info(f'write_videofile {outBase} start')

        try:

        except (StopIteration, RuntimeError):

        log.info('write_videofile done')

        self.currentOutputClip = None

    def _bg_make_frame(self, video_time_secs):

        if self.nextWriteAction == 'close':

            raise StopIteration # the one in write_videofile

        # should be a queue to miss fewer frames

        while self.nextImg is None:

            time.sleep(.03)

        cf, self.nextImg = self.nextImg, None

        return numpy.asarray(cf.img)

class GstSource:

    def __init__(self, dev):

        """

        make new gst pipeline

        """

        Gst.init(None)

        self.musicTime = MusicTime(pollCurvecalc=False)

        size = [640, 480]

        log.info("new pipeline using device=%s" % dev)

        # using videocrop breaks the pipeline, may be this issue

        # https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/issues/732

        pipeStr = (

            #f"v4l2src device=\"{dev}\""

            f'autovideosrc'

            f" ! videoconvert"

            f" ! appsink emit-signals=true max-buffers=1 drop=true name=end0 caps=video/x-raw,format=RGB,width={size[0]},height={size[1]}"

        log.info("pipeline: %s" % pipeStr)

        self.pipe = Gst.parse_launch(pipeStr)

        self.setupPipelineError(self.pipe, self.onError)

            finally:

                buf.unmap(mapinfo)

            # could get gst's frame time and pass it to getLatest

            latest = self.musicTime.getLatest()

            if 'song' in latest:

                self.liveImages.on_next(

        except Exception:

            traceback.print_exc()

        return Gst.FlowReturn.OK

    def setupPipelineError(self, pipe, cb):

        bus = pipe.get_bus()

    sources = ' '.join(pkg_sources())

    run(['bin/collector'])

    run(['bin/rdfdb'])

    run(['bin/keyboardcomposer'])

    run(['bin/effectsequencer'])

    run(['bin/ascoltami2'])

    #for src in bin_sources:

    #    print(f"mypy {src}")

    #    run([src])# + pkg_sources())

@task

def reformat(ctx):

    ctx.run("env/bin/yapf --verbose --parallel --in-place --style google light9/*.py light9/*/*.py `file --no-pad  bin/* | grep 'Python script' | perl -lpe 's/:.*//'`")