groups = ["default", "dev"]

strategy = ["cross_platform", "inherit_metadata"]

lock_version = "4.4.1"

[[package]]

name = "aiohttp"

]

[[package]]

name = "zope-interface"

version = "6.3"

requires_python = ">=3.7"

    "scipy>=1.9.3",

    "braillegraph>=0.6",

    "tenacity>=8.2.2",

    "mido>=1.2.10",

    "alsa-midi>=1.0.1",

    "treq>=22.2.0",

import logging

import time

from typing import Dict, List, Set, Tuple, cast

from prometheus_client import Summary

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from light9.collector.device import resolve, toOutputAttrs

from light9.collector.output import Output as OutputInstance

from light9.collector.weblisteners import WebListeners

from light9.effect.settings import DeviceSettings

from light9.namespaces import L9, RDF

log = logging.getLogger('collector')

STAT_SETATTR = Summary('set_attr', 'setAttr calls')

def makeDmxMessageIndex(base: DmxIndex, offset: DmxIndex) -> DmxMessageIndex:

    return DmxMessageIndex(base + offset - 1)

import json

import logging

import time

import zmq.asyncio

from prometheus_client import Summary

log = logging.getLogger('coll_client')

ZMQ_SEND = Summary('zmq_send', 'calls')

import logging

from rdflib import Literal, URIRef

from webcolors import hex_to_rgb, rgb_to_hex

log = logging.getLogger('device')

    return cast(HexColor, rgb_to_hex(tuple(maxes)))

    """

    return one value to use for this attr, given a set of them that

    have come in simultaneously. len(values) >= 1.

def toOutputAttrs(

        deviceType: DeviceClass,

                                ]) -> Dict[OutputAttr, OutputValue]:

    return dict((OutputAttr(u), OutputValue(v)) for u, v in untype_toOutputAttrs(deviceType, deviceAttrSettings).items())

import asyncio

import io

import logging

import time

from typing import Any, Awaitable, Dict, List, Protocol, Tuple

import fastavro

from fastavro.schema import load_schema

from light9.newtypes import (DeviceUri, DmxIndex, DmxMessageIndex, OutputAttr, OutputUri, OutputValue)

import starlette.websockets

import websockets

        out = io.BytesIO()

        fastavro.schemaless_writer(out, self.CollectorUpdateSchema, {'OutputAttrsSet': {'dev': dev, 'attrs': attrRows}})

        msg = out.getvalue()

        return msg

from twisted.internet.defer import inlineCallbacks, returnValue

from light9 import networking

from light9.curvecalc.curve import CurveResource

from light9.namespaces import L9, RDF, RDFS

def clamp(x, lo, hi):

            ] + [(effect, L9['code'], c, ctx) for c in droppedCodes])

        elif L9['Submaster'] in droppedTypes:

            quads.extend([

            ])

        else:

        _maybeAddMusicLine(quads, effect, song, ctx)

        if L9['Effect'] in droppedTypes:

            musicStatus = yield getMusicStatus()

            songTime = musicStatus['t']

        else:

            raise NotImplementedError

def _point(ctx, uri, t, v):

def _finishCurve(graph, note, quads, ctx, songTime):

    pt2 = graph.sequentialUri(curve + 'p')

    pt3 = graph.sequentialUri(curve + 'p')

                 _point(ctx, pt3, songTime - origin + .5, 0))

    for spoc in quads:

        if spoc[1] == L9['code'] and 'music' in spoc[2]:

            break

import logging

import random

from PIL import Image

from webcolors import rgb_to_hex

from light9.effect.scale import scale

from light9.effect.settings import DeviceSettings

from light9.namespaces import L9

random.seed(0)

log = logging.getLogger('effectfunc')

    if not (0 <= y < img.height):

        return (0, 0, 0)

    if 0 <= x < img.width:

) -> DeviceSettings:

    x = int((songTime / period) * image.width)

    out = []

        if da != L9['color']:

            continue

        color8 = sample8(image, x, y, repeat=True)

import inspect

import logging

from dataclasses import dataclass

from typing import Callable, List, Optional

from light9.effect.effect_function_library import EffectFunctionLibrary

from light9.effect.settings import DeviceSettings, EffectSettings

from light9.namespaces import L9

from light9.typedgraph import typedValue

log = logging.getLogger('effecteval')

from decimal import Decimal

from webcolors import hex_to_rgb, rgb_to_hex

from light9.newtypes import VTUnion

def scale(value: VTUnion, strength: float):

    if isinstance(value, Decimal):

import logging

import time

from dataclasses import dataclass

from typing import List, Optional, cast

from starlette.routing import Route

from starlette_exporter import PrometheusMiddleware, handle_metrics

from light9.background_loop import loop_forever

from light9.collector.collector_client_asyncio import sendToCollector

from light9.effect.effect_function_library import EffectFunctionLibrary

from light9.effect.sequencer.eval_faders import FaderEval

from light9.collector.device import resolve

from light9.localsyncedgraph import LocalSyncedGraph

from light9.namespaces import L9, RDF

log = logging.getLogger('settings')