def test_changing_port(self):
""" Validate port parsing """
led = LedController("127.0.0.1", port=123)
self.assertEqual(led.gateway_port, 123)
led = LedController("127.0.0.1", port="123")
self.assertEqual(led.gateway_port, 123)
with self.assertRaises(ValueError):
LedController("127.0.0.1", port=0)
def test_sleep(self): # pylint: disable=no-self-use
""" Verify sleeps between subsequent commands """
led = LedController("127.0.0.1", pause_between_commands=0.5, repeat_commands=1)
start_time = time.time()
led.on()
self.assertLess(time.time() - start_time, 0.45) # there is no sleep for a single command
led.off() # this command needs to wait almost 0.5 seconds
self.assertGreater(time.time() - start_time, 0.45)
def test_when_no_tag_outputs_zeros(self):
device = Mock()
controller = LedController(device)
controller.show()
device.show.assert_called_with([[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
def test_changing_repeat_commands(self):
""" Change number of repeated commands """
led = LedController("127.0.0.1", repeat_commands=0)
self.assertEqual(led.repeat_commands, 1)
led = LedController("127.0.0.1", repeat_commands=1)
self.assertEqual(led.repeat_commands, 1)
led = LedController("127.0.0.1", repeat_commands=2)
self.assertEqual(led.repeat_commands, 2)
with self.assertRaises(ValueError):
LedController("127.0.0.1", repeat_commands=-1)
def run_timed_actions():
""" Runs light programs """
led = LedController(settings.MILIGHT_IP)
now = timezone.now()
allowed_groups = set()
for group in range(1, 5):
if redis_instance.get("lightcontrol-no-automatic-%s" % group) is None:
allowed_groups.add(group)
for item in LightAutomation.objects.filter(running=True):
if not item.is_running(now):
continue
percent_done = item.percent_done(now)
logger.debug("Running %s, done %s%%", item.action, percent_done)
brightness = None # Set brightness
if item.action == "evening" or item.action == "evening-weekend":
brightness = int((1-percent_done)*100)
elif item.action == "morning" or item.action == "morning-weekend":
brightness = int(percent_done * 100)
if not item.action_if_off:
# Don't turn on lights
for group in list(allowed_groups): # cast to list to avoid "Set changed size during iteration"
group_item, _ = LightGroup.objects.get_or_create(group_id=group)
if group_item.on == False:
allowed_groups.remove(group)
logger.debug("Only run on %s", allowed_groups)
if item.set_white:
for group in allowed_groups:
led.white(group)
logger.debug("Set %s to white", group)
update_lightstate(group, None, "white", important=False)
if brightness:
logger.debug("Setting brightness to %s%%", brightness)
publish_ws("lightcontrol-timed-brightness-%s" % item.action, brightness)
for group in allowed_groups:
group_brightness = brightness
group_item, _ = LightGroup.objects.get_or_create(group_id=group)
if item.no_brighten:
logger.debug("Current brightness: %s%%", group_item.current_brightness)
if group_item.current_brightness is not None:
group_brightness = min(group_item.current_brightness, group_brightness)
if item.no_dimming:
logger.debug("Current brightness: %s%%", group_item.current_brightness)
if group_item.current_brightness is not None:
group_brightness = max(group_item.current_brightness, group_brightness)
if group_item.current_brightness:
if led.get_brightness_level(group_brightness) == led.get_brightness_level(group_item.current_brightness):
logger.debug("Not sending brightness update to %s: no difference in brightness level", group)
continue
logger.debug("Setting %s to %s", (group, group_brightness))
led.set_brightness(group_brightness, group)
update_lightstate(group, group_brightness, important=False)
set_destination_brightness()
def test_default_constructor(self):
""" Verify default settings """
led = LedController("127.0.0.1")
self.assertEqual(led.gateway_ip, "127.0.0.1")
self.assertEqual(led.gateway_port, 8899)
self.assertEqual(led.repeat_commands, 3)
self.assertEqual(led.pause_between_commands, 0.1)
def setUp(self):
self.led = LedController("127.0.0.1",
pause_between_commands=0,
repeat_commands=0,
group_1="rgbw",
group_2="white",
group_3="rgbw",
group_4="white")
def test_when_tacking_tag_set_then_cleared_will_show_zero(self):
device = Mock()
controller = LedController(device)
controller.set_have_tracking_tag()
controller.clear_tag()
controller.show()
device.show.assert_called_with([[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
def test_when_progress_tag_set_then_cleared_will_show_zero(self):
device = Mock()
controller = LedController(device)
controller.set_progress(60, 30)
controller.clear_tag()
controller.show()
device.show.assert_called_with([[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0],
[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
def test_sleep(self): # pylint: disable=no-self-use
""" Verify sleeps between subsequent commands """
led = LedController("127.0.0.1",
pause_between_commands=0.5,
repeat_commands=1)
start_time = time.time()
led.on()
self.assertLess(time.time() - start_time,
0.45) # there is no sleep for a single command
led.off() # this command needs to wait almost 0.5 seconds
self.assertGreater(time.time() - start_time, 0.45)
def test_when_set_unknown_tag_it_calls_show_unknown_tag(self):
device = Mock()
controller = LedController(device)
controller.set_unknown_tag()
controller.show()
device.show.assert_called_once()
device.show.assert_called_with([[0, 0, 255], [255, 0, 0], [0, 0, 255], [255, 0, 0], [0, 0, 255],
[255, 0, 0], [0, 0, 255], [255, 0, 0], [0, 0, 255], [255, 0, 0],
[0, 0, 255], [255, 0, 0], [0, 0, 255], [255, 0, 0], [0, 0, 255],
[255, 0, 0], [0, 0, 255], [255, 0, 0], [0, 0, 255], [255, 0, 0],
[0, 0, 255], [255, 0, 0], [0, 0, 255], [255, 0, 0]])
def test_when_set_have_tracking_tag_it_calls_show_tracking_display(self):
device = Mock()
controller = LedController(device)
controller.set_have_tracking_tag()
controller.show()
controller.show()
self.assertEqual(device.show.call_count, 2)
device.show.assert_called_with([[0, 0, 255], [0, 0, 255], [0, 0, 255], [0, 0, 255], [0, 0, 255],
[0, 0, 255], [0, 0, 255], [0, 0, 255], [0, 0, 255], [0, 0, 255],
[0, 0, 255], [0, 0, 255], [0, 0, 255], [0, 0, 255], [0, 0, 255],
[0, 0, 255], [0, 0, 255], [0, 0, 255], [0, 0, 255], [0, 0, 255],
[0, 0, 255], [0, 0, 255], [0, 0, 255], [0, 0, 255]])
def test_sleep(self):
led = LedController("127.0.0.1")
led.on()
led.off()
from django.conf import settings
from django.core import serializers
from django.db import models
from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
from django.utils import timezone
from homedisplay.utils import publish_ws
from ledcontroller import LedController
import datetime
import json
import logging
import redis
__all__ = ["LightGroup", "LightAutomation", "update_lightstate", "is_any_timed_running", "get_serialized_timed_action", "get_serialized_lightgroup"]
led = LedController(settings.MILIGHT_IP)
redis_instance = redis.StrictRedis()
logger = logging.getLogger(__name__)
def get_morning_light_level(group_id=None):
# TODO: this is called relatively often, and this fetches all LightGroup objects on every iteration.
max_brightness = 0
items = LightGroup.objects.filter(on=True)
if group_id is None or group_id == 0:
# Process all groups
for g in items:
max_brightness = max(g.current_brightness or 0, max_brightness)
return min(10, max_brightness)
else:
# Process only a single group
"""
LED Driver
This is the actual thing that drives the LEDS
"""
from patternmanager import PatternManager
from ledcontroller import LedController
from ledview import LedView
LED_DIMENSIONS = (14, 14)
colors = []
for row in range(LED_DIMENSIONS[0]):
new = []
for col in range(LED_DIMENSIONS[1]):
new.append(0xff00ff)
colors.append(new)
pm = PatternManager(colors, LED_DIMENSIONS)
lv = LedView(colors, LED_DIMENSIONS, pm.update)
lc = LedController(pm)
lv.draw()
class TestRgbwLights(unittest.TestCase): # pylint: disable=too-many-public-methods
"""
Common tests for different setups (light combinations). Also default tests (rgbw only).
"""
def setUp(self):
self.led = LedController("127.0.0.1", pause_between_commands=0, repeat_commands=0)
def test_on(self):
""" Turn on lights """
self.led.on()
for group_id in range(5):
self.led.on(group_id)
def test_off(self):
""" Turn off lights """
self.led.off()
for group_id in range(5):
self.led.off(group_id)
def test_white(self):
""" Set lights to white """
self.led.white()
for group_id in range(5): # intentionally includes 0-4, as 0 is a special case
self.led.white(group_id)
self.led.white(None)
def test_set_color(self):
""" Set lights to predefined colors """
self.led.set_color("white")
self.led.set_color("red")
def test_set_color_by_int(self):
""" Set lights to color (int) """
self.led.set_color(0)
self.led.set_color(1)
self.led.set_color(156)
self.led.set_color(255)
with self.assertRaises(AttributeError):
self.led.set_color(-1)
with self.assertRaises(AttributeError):
self.led.set_color(256)
def test_set_brightness(self):
""" Set brightness """
self.assertEqual(self.led.set_brightness(-1), 0, "negative brightness not clamped properly")
self.assertEqual(self.led.set_brightness(101), 100, ">100 brightness not clamped properly")
self.assertEqual(self.led.set_brightness(50), 50, "50% outputs != 50%")
def test_set_brightness_float(self):
""" Set brightness (float) """
self.assertEqual(self.led.set_brightness(0.1), 10, "float(0.1) not parsed to 10%")
self.assertEqual(self.led.set_brightness(1.0), 100, "float(1.0) not parsed to 100%")
self.assertEqual(self.led.set_brightness(50.0), 50, "float(50.0) not parsed to 50%")
def test_disco(self):
""" Enable disco mode """
self.led.disco()
for group_id in range(5):
self.led.disco(group_id)
def test_disco_faster(self):
""" Increase disco mode speed """
self.led.disco_faster()
for group_id in range(5):
self.led.disco_faster(group_id)
def test_disco_slower(self):
""" Decrease disco mode speed """
self.led.disco_slower()
for group_id in range(5):
self.led.disco_slower(group_id)
def test_nightmode(self):
""" Enable nightmode """
self.led.nightmode()
for group_id in range(5):
self.led.nightmode(group_id)
def test_warmer(self):
""" Test white light -> warmer """
self.led.warmer()
for group_id in range(5):
self.led.warmer(group_id)
def test_cooler(self):
""" Test white light -> cooler """
self.led.cooler()
for group_id in range(5):
self.led.cooler(group_id)
def test_brightness_up(self):
""" Increase brightness """
self.led.brightness_up()
for group_id in range(5):
self.led.brightness_up(group_id)
def test_brightness_down(self):
""" Decrease brightness """
self.led.brightness_down()
for group_id in range(5):
self.led.brightness_down(group_id)
def test_batch_run(self):
""" Batch run multiple commands """
led = self.led
led.batch_run((led.set_brightness, 10, 3), (led.set_color, "red"), (led.off,))
def test_invalid_group_type(self):
""" Set invalid group type """
self.assertRaises(AttributeError, self.led.set_group_type, 1, "asdf")
def test_invalid_group_number(self):
""" Set invalid group number """
self.assertRaises(AttributeError, self.led.on, 5)
def setUp(self):
self.led = LedController("127.0.0.1",
pause_between_commands=0,
repeat_commands=0)
class TestRgbwLights(unittest.TestCase):
def setUp(self):
self.led = LedController("127.0.0.1",
pause_between_commands=0,
repeat_commands=0)
def test_default_constructor(self):
led = LedController("127.0.0.1")
self.assertEqual(led.gateway_ip, "127.0.0.1")
self.assertEqual(led.gateway_port, 8899)
self.assertEqual(led.repeat_commands, 3)
self.assertEqual(led.pause_between_commands, 0.1)
def test_changing_port(self):
led = LedController("127.0.0.1", port=123)
self.assertEqual(led.gateway_port, 123)
led = LedController("127.0.0.1", port="123")
self.assertEqual(led.gateway_port, 123)
def test_sleep(self):
led = LedController("127.0.0.1")
led.on()
led.off()
def test_changing_pause(self):
led = LedController("127.0.0.1", pause_between_commands=0.8)
self.assertEqual(led.pause_between_commands, 0.8)
def test_changing_repeat_commands(self):
led = LedController("127.0.0.1", repeat_commands=0)
self.assertEqual(led.repeat_commands, 1)
def test_on(self):
self.led.on()
self.led.on(1)
def test_off(self):
self.led.off()
self.led.off(2)
def test_white(self):
self.led.white()
for a in range(5):
self.led.white(a)
self.led.white(None)
def test_set_color(self):
self.led.set_color("white")
self.led.set_color("red")
def test_set_brightness(self):
self.assertEquals(self.led.set_brightness(-1), 0,
"negative brightness not clamped properly")
self.assertEquals(self.led.set_brightness(101), 100,
">100 brightness not clamped properly")
self.assertEquals(self.led.set_brightness(50), 50,
"50% outputs != 50%")
def test_set_brightness_float(self):
self.assertEquals(self.led.set_brightness(0.1), 10,
"float(0.1) not parsed to 10%")
self.assertEquals(self.led.set_brightness(1.0), 100,
"float(1.0) not parsed to 100%")
self.assertEquals(self.led.set_brightness(50.0), 50,
"float(50.0) not parsed to 50%")
def test_disco(self):
self.led.disco(1)
self.led.disco()
def test_disco_faster(self):
self.led.disco_faster(1)
self.led.disco_faster()
def test_disco_slower(self):
self.led.disco_slower(1)
self.led.disco_slower()
def test_nightmode(self):
self.led.nightmode()
self.led.nightmode(1)
def test_warmer(self):
self.led.warmer()
self.led.warmer(1)
def test_cooler(self):
self.led.cooler()
self.led.cooler(4)
def test_brightness_up(self):
self.led.brightness_up()
self.led.brightness_up(4)
def test_brightness_down(self):
self.led.brightness_down()
self.led.brightness_down(4)
def test_batch_run(self):
led = self.led
led.batch_run((led.set_brightness, 10, 3), (led.set_color, "red"),
(led.off, ))
def test_invalid_group_type(self):
self.assertRaises(AttributeError, self.led.set_group_type, 1, "asdf")
def test_invalid_group_number(self):
self.assertRaises(AttributeError, self.led.on, 5)
def test_changing_repeat_commands(self):
led = LedController("127.0.0.1", repeat_commands=0)
self.assertEqual(led.repeat_commands, 1)
def test_changing_pause(self):
led = LedController("127.0.0.1", pause_between_commands=0.8)
self.assertEqual(led.pause_between_commands, 0.8)
def test_sleep(self):
led = LedController("127.0.0.1")
led.on()
led.off()
def test_changing_port(self):
led = LedController("127.0.0.1", port=123)
self.assertEqual(led.gateway_port, 123)
led = LedController("127.0.0.1", port="123")
self.assertEqual(led.gateway_port, 123)
def test_changing_pause(self):
""" Change pause times """
led = LedController("127.0.0.1", pause_between_commands=0.8)
self.assertEqual(led.pause_between_commands, 0.8)
with self.assertRaises(ValueError):
LedController("127.0.0.1", pause_between_commands=-0.1)
{
'group_id' : 3,
'color':'white'
},
{
'group_id' : 4,
'color':'white'
}
]
}
]
ledcontroller_list = []
for bridge in bridge_list:
controller = LedController(bridge['ip'])
for group in bridge['group_list']:
controller.set_group_type(group['group_id'], group['color'])
ledcontroller_list.append(controller)
comm_manager = CommManager(ledcontroller_list)
living_room_lz = LightZone('Living Room - All', ledcontroller_list[0], 1)
kitchen_lz = LightZone('Kitchen - All', ledcontroller_list[1], 2)
bedroom_lz = LightZone('Bedroom', ledcontroller_list[1], 3)
bedside_lz = LightZone('Bedside Lamp', ledcontroller_list[0], 2)
bathroom_lz = LightZone('Bathroom - Overhead',ledcontroller_list[1], 4)
front_door_lz = LightZone('Front Door - Overhead', ledcontroller_list[0], 3, special = True)
class TestRgbwLights(unittest.TestCase):
def setUp(self):
self.led = LedController("127.0.0.1", pause_between_commands=0, repeat_commands=0)
def test_default_constructor(self):
led = LedController("127.0.0.1")
self.assertEqual(led.gateway_ip, "127.0.0.1")
self.assertEqual(led.gateway_port, 8899)
self.assertEqual(led.repeat_commands, 3)
self.assertEqual(led.pause_between_commands, 0.1)
def test_changing_port(self):
led = LedController("127.0.0.1", port=123)
self.assertEqual(led.gateway_port, 123)
led = LedController("127.0.0.1", port="123")
self.assertEqual(led.gateway_port, 123)
def test_sleep(self):
led = LedController("127.0.0.1")
led.on()
led.off()
def test_changing_pause(self):
led = LedController("127.0.0.1", pause_between_commands=0.8)
self.assertEqual(led.pause_between_commands, 0.8)
def test_changing_repeat_commands(self):
led = LedController("127.0.0.1", repeat_commands=0)
self.assertEqual(led.repeat_commands, 1)
def test_on(self):
self.led.on()
self.led.on(1)
def test_off(self):
self.led.off()
self.led.off(2)
def test_white(self):
self.led.white()
for a in range(5):
self.led.white(a)
self.led.white(None)
def test_set_color(self):
self.led.set_color("white")
self.led.set_color("red")
def test_set_brightness(self):
self.assertEquals(self.led.set_brightness(-1), 0, "negative brightness not clamped properly")
self.assertEquals(self.led.set_brightness(101), 100, ">100 brightness not clamped properly")
self.assertEquals(self.led.set_brightness(50), 50, "50% outputs != 50%")
def test_set_brightness_float(self):
self.assertEquals(self.led.set_brightness(0.1), 10, "float(0.1) not parsed to 10%")
self.assertEquals(self.led.set_brightness(1.0), 100, "float(1.0) not parsed to 100%")
self.assertEquals(self.led.set_brightness(50.0), 50, "float(50.0) not parsed to 50%")
def test_disco(self):
self.led.disco(1)
self.led.disco()
def test_disco_faster(self):
self.led.disco_faster(1)
self.led.disco_faster()
def test_disco_slower(self):
self.led.disco_slower(1)
self.led.disco_slower()
def test_nightmode(self):
self.led.nightmode()
self.led.nightmode(1)
def test_warmer(self):
self.led.warmer()
self.led.warmer(1)
def test_cooler(self):
self.led.cooler()
self.led.cooler(4)
def test_brightness_up(self):
self.led.brightness_up()
self.led.brightness_up(4)
def test_brightness_down(self):
self.led.brightness_down()
self.led.brightness_down(4)
def test_batch_run(self):
led = self.led
led.batch_run((led.set_brightness, 10, 3), (led.set_color, "red"), (led.off,))
def test_invalid_group_type(self):
self.assertRaises(AttributeError, self.led.set_group_type, 1, "asdf")
def test_invalid_group_number(self):
self.assertRaises(AttributeError, self.led.on, 5)
class TestRgbwLights(unittest.TestCase): # pylint: disable=too-many-public-methods
"""
Common tests for different setups (light combinations). Also default tests (rgbw only).
"""
def setUp(self):
self.led = LedController("127.0.0.1",
pause_between_commands=0,
repeat_commands=0)
def test_on(self):
""" Turn on lights """
self.led.on()
for group_id in range(5):
self.led.on(group_id)
def test_off(self):
""" Turn off lights """
self.led.off()
for group_id in range(5):
self.led.off(group_id)
def test_white(self):
""" Set lights to white """
self.led.white()
for group_id in range(
5): # intentionally includes 0-4, as 0 is a special case
self.led.white(group_id)
self.led.white(None)
def test_set_color(self):
""" Set lights to predefined colors """
self.led.set_color("white")
self.led.set_color("red")
def test_set_color_by_int(self):
""" Set lights to color (int) """
self.led.set_color(0)
self.led.set_color(1)
self.led.set_color(156)
self.led.set_color(255)
with self.assertRaises(AttributeError):
self.led.set_color(-1)
with self.assertRaises(AttributeError):
self.led.set_color(256)
def test_set_brightness(self):
""" Set brightness """
self.assertEqual(self.led.set_brightness(-1), 0,
"negative brightness not clamped properly")
self.assertEqual(self.led.set_brightness(101), 100,
">100 brightness not clamped properly")
self.assertEqual(self.led.set_brightness(50), 50, "50% outputs != 50%")
def test_set_brightness_float(self):
""" Set brightness (float) """
self.assertEqual(self.led.set_brightness(0.1), 10,
"float(0.1) not parsed to 10%")
self.assertEqual(self.led.set_brightness(1.0), 100,
"float(1.0) not parsed to 100%")
self.assertEqual(self.led.set_brightness(50.0), 50,
"float(50.0) not parsed to 50%")
def test_disco(self):
""" Enable disco mode """
self.led.disco()
for group_id in range(5):
self.led.disco(group_id)
def test_disco_faster(self):
""" Increase disco mode speed """
self.led.disco_faster()
for group_id in range(5):
self.led.disco_faster(group_id)
def test_disco_slower(self):
""" Decrease disco mode speed """
self.led.disco_slower()
for group_id in range(5):
self.led.disco_slower(group_id)
def test_nightmode(self):
""" Enable nightmode """
self.led.nightmode()
for group_id in range(5):
self.led.nightmode(group_id)
def test_warmer(self):
""" Test white light -> warmer """
self.led.warmer()
for group_id in range(5):
self.led.warmer(group_id)
def test_cooler(self):
""" Test white light -> cooler """
self.led.cooler()
for group_id in range(5):
self.led.cooler(group_id)
def test_brightness_up(self):
""" Increase brightness """
self.led.brightness_up()
for group_id in range(5):
self.led.brightness_up(group_id)
def test_brightness_down(self):
""" Decrease brightness """
self.led.brightness_down()
for group_id in range(5):
self.led.brightness_down(group_id)
def test_batch_run(self):
""" Batch run multiple commands """
led = self.led
led.batch_run((led.set_brightness, 10, 3), (led.set_color, "red"),
(led.off, ))
def test_invalid_group_type(self):
""" Set invalid group type """
self.assertRaises(AttributeError, self.led.set_group_type, 1, "asdf")
def test_invalid_group_number(self):
""" Set invalid group number """
self.assertRaises(AttributeError, self.led.on, 5)
def setUp(self):
self.led = LedController("127.0.0.1", pause_between_commands=0, repeat_commands=0)
def log_tag(self, tag_id, start, end):
self.tag_repository.log_tag(tag_id, self.device_id, start, end)
if __name__ == "__main__":
from ledcontroller import LedController
if len(sys.argv) == 2 and sys.argv[1] == "test":
from timeularapi import TimularApi
from tagrepository import TagRepository
from mockleddevice import MockLedDevice
from mockrfireader import MockRfiReader
logging.basicConfig(level=logging.DEBUG)
led_device = MockLedDevice()
led_controller = LedController(led_device)
reader = MockRfiReader()
configuration = Configuration("debug_config.json")
tag_repository = TagRepository(configuration)
api = TimularApi(configuration, tag_repository)
else:
if len(sys.argv) == 2 and sys.argv[1] == "debug":
logging.basicConfig(level=logging.DEBUG)
if len(sys.argv) == 2 and sys.argv[1] == "info":
logging.basicConfig(level=logging.INFO)
from rfidevice import RfiDevice
from timeularapi import TimularApi
from leddevice import LedDevice
from tagrepository import TagRepository
configuration = Configuration("configuration.json")
led_device = LedDevice(configuration)
