from rdflib import Literal, URIRef

from light9.namespaces import L9, DEV

from webcolors import rgb_to_hex, hex_to_rgb

from colorsys import hsv_to_rgb

import math

from noise import pnoise1

import logging

from light9.effect.settings import DeviceSettings

from light9.effect.scale import scale

from typing import Dict, Tuple, Any

import random

random.seed(0)

log = logging.getLogger('effecteval')

def literalColor(rnorm, gnorm, bnorm):

    return Literal(

        rgb_to_hex([int(rnorm * 255),

                    int(gnorm * 255),

                    int(bnorm * 255)]))

def literalColorHsv(h, s, v):

    return literalColor(*hsv_to_rgb(h, s, v))

def nsin(x):

    return (math.sin(x * (2 * math.pi)) + 1) / 2

def ncos(x):

    return (math.cos(x * (2 * math.pi)) + 1) / 2

def nsquare(t, on=.5):

    return (t % 1.0) < on

        self.onChange = onChange

        self.notifier = INotify()

        self.notifier.startReading()

        self.notifier.watch(FilePath(effecteval.__file__.replace('.pyc',

                                                                 '.py')),

                            callbacks=[self.codeChange])

    def codeChange(self, watch, path, mask):

        def go():

            log.info("reload effecteval")

            imp.reload(effecteval)

            self.onChange()

        # in case we got an event at the start of the write

        reactor.callLater(.1, go)

class Sequencer(object):

    def __init__(

            self,

            graph: SyncedGraph,

            fps=40):

        self.graph = graph

        self.fps = fps

        updateStats.goalFps = self.fps

        updateStats.updateLoopLatencyGoal = 1 / self.fps

        self.sendToCollector = sendToCollector

        self.music = MusicTime(period=.2, pollCurvecalc=False)

        self.recentUpdateTimes: List[float] = []

        self.lastStatLog = 0.0

        self._compileGraphCall = None

        self.notes: Dict[Song, List[Note]] = {}  # song: [notes]

        self.simpleOutputs = SimpleOutputs(self.graph)

        self.graph.addHandler(self.compileGraph)

        self.updateLoop()

        self.codeWatcher = CodeWatcher(

            onChange=lambda: self.graph.addHandler(self.compileGraph))

    @compileStats.graph.time()

    def compileGraph(self) -> None:

        """rebuild our data from the graph"""

        for song in self.graph.subjects(RDF.type, L9['Song']):