def show(self, position=1):
from blink import Blink
blink = Blink()
screen_geometry = blink.desktop().screenGeometry(self)
available_geometry = blink.desktop().availableGeometry(self)
main_window_geometry = blink.main_window.geometry()
main_window_framegeometry = blink.main_window.frameGeometry()
horizontal_decorations = main_window_framegeometry.width() - main_window_geometry.width()
vertical_decorations = main_window_framegeometry.height() - main_window_geometry.height()
width = limit(self.sizeHint().width(), min=self.minimumSize().width(), max=min(self.maximumSize().width(), available_geometry.width()-horizontal_decorations))
height = limit(self.sizeHint().height(), min=self.minimumSize().height(), max=min(self.maximumSize().height(), available_geometry.height()-vertical_decorations))
total_width = width + horizontal_decorations
total_height = height + vertical_decorations
x = limit(screen_geometry.center().x() - total_width/2, min=available_geometry.left(), max=available_geometry.right()-total_width)
if position is None:
y = -1
elif position % 2 == 0:
y = screen_geometry.center().y() + (position-1)*total_height/2
else:
y = screen_geometry.center().y() - position*total_height/2
if available_geometry.top() <= y <= available_geometry.bottom() - total_height:
self.setGeometry(x, y, width, height)
else:
self.resize(width, height)
self.position = position
super(PendingWatcherDialog, self).show()
def initialize(self):
"""Initialize WinSparkle library, it will try to fetch updates in the background"""
from blink import Blink, __version__
application = Blink()
settings = SIPSimpleSettings()
winsparkle_set_appcast_url(settings.server.updater_url)
winsparkle_set_app_details(application.organizationName(), application.applicationName(), __version__)
winsparkle_init()
def connect():
"""Connect to internet"""
my_networks = json.loads(open('networks.json').read())
led16 = Blink(16)
led2 = Blink(2)
sta_if = network.WLAN(network.STA_IF)
# scan what’s available
available_networks = []
for net in sta_if.scan():
ssid = net[0].decode("utf-8")
bssid = net[1]
strength = net[3]
available_networks.append(dict(ssid=ssid, bssid=bssid, strength=strength))
# Sort fields by strongest first in case of multiple SSID access points
available_networks.sort(key=lambda station: station["strength"], reverse=True)
if not sta_if.isconnected():
led16.blink(2, 0.2)
for config in my_networks['known_networks']:
for ssid in available_networks:
if config["ssid"] == ssid["ssid"]:
print('connecting to network {0} ...'.format(config["ssid"]))
sta_if.active(True)
sta_if.connect(config["ssid"], config["password"])
print('network config:', sta_if.ifconfig())
led2.blink(1, 0.2)
def _test_download_thumbnail(self):
'''doesn't work'''
b = Blink()
b.connect()
network_id = b.networks[0]['id']
events = b.events(network_id)
event = events[0]
b.download_thumbnail(event)
def show(self, position=1):
from blink import Blink
blink = Blink()
screen_geometry = blink.desktop().screenGeometry(self)
available_geometry = blink.desktop().availableGeometry(self)
main_window_geometry = blink.main_window.geometry()
main_window_framegeometry = blink.main_window.frameGeometry()
horizontal_decorations = main_window_framegeometry.width(
) - main_window_geometry.width()
vertical_decorations = main_window_framegeometry.height(
) - main_window_geometry.height()
width = limit(self.sizeHint().width(),
min=self.minimumSize().width(),
max=min(
self.maximumSize().width(),
available_geometry.width() - horizontal_decorations))
height = limit(self.sizeHint().height(),
min=self.minimumSize().height(),
max=min(
self.maximumSize().height(),
available_geometry.height() - vertical_decorations))
total_width = width + horizontal_decorations
total_height = height + vertical_decorations
x = limit(screen_geometry.center().x() - total_width / 2,
min=available_geometry.left(),
max=available_geometry.right() - total_width)
if position is None:
y = -1
elif position % 2 == 0:
y = screen_geometry.center().y() + (position -
1) * total_height / 2
else:
y = screen_geometry.center().y() - position * total_height / 2
if available_geometry.top(
) <= y <= available_geometry.bottom() - total_height:
self.setGeometry(x, y, width, height)
else:
self.resize(width, height)
self.position = position
super(PendingWatcherDialog, self).show()
def __init__(self):
self.config = Config()
self.not_read_channels = []
self.blink = Blink()
self.mattermost_driver = Driver({
'url':
self.config.get_string('MATTERMOST', 'url'),
'login_id':
self.config.get_string('MATTERMOST', 'login_id'),
'password':
self.config.get_string('MATTERMOST', 'password'),
'verify':
self.config.get_bool('MATTERMOST', 'verify'),
'scheme':
self.config.get_string('MATTERMOST', 'scheme'),
'port':
self.config.get_int('MATTERMOST', 'port'),
'debug':
self.config.get_bool('MATTERMOST', 'debug')
})
self.ignored_channels = self.config.get_string(
'MATTERMOST', 'ignored_channels').split(',')
self.server = None
self.start()
def process_command(request, cmd):
# Must be an absolute path (ex: no ~/bin/)
blink = Blink()
# Map these directly to --<string> with no interference. Ex: on should map to --on
direct_map = ['on', 'off', 'red', 'blue', 'green']
if cmd == 'random' and 'numtimes' in request.GET:
blink.random(request.GET['numtimes'])
elif cmd == 'rgb' and 'r' in request.GET and 'g' in request.GET and 'b' in request.GET:
blink.rgb(request.GET['r'], request.GET['g'], request.GET['b'])
elif cmd in direct_map:
blink.cmd('--' + cmd)
else:
return HttpResponse('Invalid Command')
return HttpResponse(0)
def _main():
config_fn = os.path.join(os.path.expanduser("~"), '.blinkconfig')
if os.path.isfile(config_fn):
with open(config_fn) as f:
config = yaml.load(f.read())
if isinstance(config, dict):
if len(config) == 1:
_email, _password = list(config.items())[0]
if len(config) > 1:
raise Exception(
'Multiple email/passwords found in .blinkconfig. Please specify which ones to use.'
)
else:
raise Exception(
'File .blinkconfig must be a YAML dictionary. Currently it is a %s.'
% type(config))
args = sys.argv[1:]
if len(args) > 1 and args[0] == '--archive':
Blink(_email, _password).archive(args[1])
else:
print(f'Usage:\n\t{sys.argv[0]} --archive <dest_dir>')
def test_clients(self):
b = Blink()
print b.clients()
def _test_arm(self):
b = Blink()
b.connect()
print b.arm(b.networks[0])
def test_connect(self):
b = Blink()
self.assertFalse(b.connected)
b.connect()
self.assertTrue(b.connected)
def test_sync_modules(self):
b = Blink()
b.connect()
sync_modules = b.sync_modules(b.networks[0])
print sync_modules
def _create_sip_account(self,
username,
password,
email_address,
display_name,
timezone=None):
red = '#cc0000'
if timezone is None and sys.platform != 'win32':
try:
timezone = open('/etc/timezone').read().strip()
except (OSError, IOError):
try:
timezone = '/'.join(
os.readlink('/etc/localtime').split('/')[-2:])
except (OSError, IOError):
pass
enrollment_data = dict(username=username.lower().encode('utf-8'),
password=password.encode('utf-8'),
email=email_address.encode('utf-8'),
display_name=display_name.encode('utf-8'),
tzinfo=timezone)
try:
settings = SIPSimpleSettings()
response = urllib2.urlopen(settings.server.enrollment_url,
urllib.urlencode(dict(enrollment_data)))
response_data = cjson.decode(response.read().replace(r'\/', '/'))
response_data = defaultdict(lambda: None, response_data)
if response_data['success']:
from blink import Blink
try:
certificate_path = None
passport = response_data['passport']
if passport is not None:
certificate_path = Blink().save_certificates(
response_data['sip_address'], passport['crt'],
passport['key'], passport['ca'])
except (GNUTLSError, IOError, OSError):
pass
account_manager = AccountManager()
try:
account = Account(response_data['sip_address'])
except DuplicateIDError:
account = account_manager.get_account(
response_data['sip_address'])
account.enabled = True
account.display_name = display_name or None
account.auth.password = password
account.sip.outbound_proxy = response_data['outbound_proxy']
account.nat_traversal.msrp_relay = response_data['msrp_relay']
account.xcap.xcap_root = response_data['xcap_root']
account.tls.certificate = certificate_path
account.server.conference_server = response_data[
'conference_server']
account.server.settings_url = response_data['settings_url']
account.save()
account_manager.default_account = account
call_in_gui_thread(self.accept)
elif response_data['error'] == 'user_exists':
call_in_gui_thread(self.username_editor.addException, username)
else:
call_in_gui_thread(
setattr, self.create_status_label, 'value',
Status(response_data['error_message'], color=red))
except (cjson.DecodeError, KeyError):
call_in_gui_thread(setattr, self.create_status_label, 'value',
Status('Illegal server response', color=red))
except urllib2.URLError, e:
call_in_gui_thread(
setattr, self.create_status_label, 'value',
Status('Failed to contact server: %s' % e.reason, color=red))
def setUp(self):
self.b = Blink(self.email, self.password)
self.b.login()
import pyaudio
import audioop
from blink import Blink
b = Blink()
CHUNK = 1024
WIDTH = 2
CHANNELS = 2
RATE = 44000 # Your device's sample rate is in p.get_device_info_by_index(0)['defaultSampleRate'].
p = pyaudio.PyAudio()
stream = p.open(format=p.get_format_from_width(WIDTH),
channels=CHANNELS,
rate=RATE,
input=True,
output=True,
frames_per_buffer=CHUNK)
print("Listening")
fade = 600
while True:
data = stream.read(CHUNK)
max = audioop.rms(data, 2)
if max > 400:
b.fade(27, 67, 187, fade, 0)
if max > 800:
b.fade(8, 210, 21, fade, 0);
if max > 1200:
b.fade(255, 15, 9, fade, 0);
def elaborate(self, platform: Platform) -> Module:
m = Module()
if platform:
clk_in = platform.request(platform.default_clk, dir='-')[0]
# Constants
pixel_f = self.timing.pixel_freq
hsync_front_porch = self.timing.h_front_porch
hsync_pulse_width = self.timing.h_sync_pulse
hsync_back_porch = self.timing.h_back_porch
vsync_front_porch = self.timing.v_front_porch
vsync_pulse_width = self.timing.v_sync_pulse
vsync_back_porch = self.timing.v_back_porch
# Clock generator.
m.domains.sync = cd_sync = ClockDomain("sync")
m.domains.pixel = cd_pixel = ClockDomain("pixel")
m.submodules.ecp5pll = pll = ECP5PLL()
pll.register_clkin(clk_in, platform.default_clk_frequency)
pll.create_clkout(cd_sync, platform.default_clk_frequency)
pll.create_clkout(cd_pixel, pixel_f)
platform.add_clock_constraint(cd_sync.clk, platform.default_clk_frequency)
platform.add_clock_constraint(cd_pixel.clk, pixel_f)
# VGA signal generator.
vga_r = Signal(8)
vga_g = Signal(8)
vga_b = Signal(8)
vga_hsync = Signal()
vga_vsync = Signal()
vga_blank = Signal()
m.submodules.vga = vga = VGA(
resolution_x = self.timing.x,
hsync_front_porch = hsync_front_porch,
hsync_pulse = hsync_pulse_width,
hsync_back_porch = hsync_back_porch,
resolution_y = self.timing.y,
vsync_front_porch = vsync_front_porch,
vsync_pulse = vsync_pulse_width,
vsync_back_porch = vsync_back_porch,
bits_x = 16, # Play around with the sizes because sometimes
bits_y = 16 # a smaller/larger value will make it pass timing.
)
with m.If(vga.o_beam_y < 240):
m.d.comb += [
vga.i_r.eq(0xff),
vga.i_g.eq(0),
vga.i_b.eq(0)
]
with m.Else():
m.d.comb += [
vga.i_r.eq(0),
vga.i_g.eq(0xff),
vga.i_b.eq(0)
]
m.d.comb += [
vga.i_clk_en.eq(1),
vga.i_test_picture.eq(0),
vga_r.eq(vga.o_vga_r),
vga_g.eq(vga.o_vga_g),
vga_b.eq(vga.o_vga_b),
vga_hsync.eq(vga.o_vga_hsync),
vga_vsync.eq(vga.o_vga_vsync),
vga_blank.eq(vga.o_vga_blank),
]
vga_out = platform.request("vga")
m.d.comb += [
vga_out.red.eq(vga_r[4:]),
vga_out.green.eq(vga_g[4:]),
vga_out.blue.eq(vga_b[4:]),
vga_out.hs.eq(vga_hsync),
vga_out.vs.eq(vga_vsync)
]
# LED blinky
counter_width = 28
countblink = Signal(8)
m.submodules.blink = blink = Blink(counter_width)
m.d.comb += [
countblink.eq(blink.o_led),
self.o_led[3:5].eq(countblink[6:8]),
self.o_led[0].eq(vga_vsync),
self.o_led[1].eq(vga_hsync),
self.o_led[2].eq(vga_blank),
]
return m
def test_regions(self):
b = Blink()
print b.regions()
class BlinkServer(object):
def __init__(self):
self.config = Config()
self.not_read_channels = []
self.blink = Blink()
self.mattermost_driver = Driver({
'url':
self.config.get_string('MATTERMOST', 'url'),
'login_id':
self.config.get_string('MATTERMOST', 'login_id'),
'password':
self.config.get_string('MATTERMOST', 'password'),
'verify':
self.config.get_bool('MATTERMOST', 'verify'),
'scheme':
self.config.get_string('MATTERMOST', 'scheme'),
'port':
self.config.get_int('MATTERMOST', 'port'),
'debug':
self.config.get_bool('MATTERMOST', 'debug')
})
self.ignored_channels = self.config.get_string(
'MATTERMOST', 'ignored_channels').split(',')
self.server = None
self.start()
def start_wbe_server(self, thread_name):
self.server = Server(self.blink)
@asyncio.coroutine
def socket_handler(self, message):
print(message)
self.handle_message(json.loads(message))
def handle_message(self, json_message):
if 'event' not in json_message:
return
if json_message['event'] == "posted":
try:
self.ignored_channels.index(
json_message['data']['channel_display_name'])
except ValueError:
self.parse_post(json.loads(json_message['data']['post']))
elif json_message['event'] == "channel_viewed":
self.mark_chanel_as_read(json_message['data']['channel_id'])
def parse_post(self, post_data):
try:
self.not_read_channels.index(post_data['channel_id'])
except ValueError:
self.not_read_channels.append(post_data['channel_id'])
self.blink.start_unread_blink()
def mark_chanel_as_read(self, channel_id):
try:
index = self.not_read_channels.index(channel_id)
del self.not_read_channels[index]
if len(self.not_read_channels) == 0:
self.blink.stop_unread_blinking()
except ValueError:
pass
def start(self):
_thread.start_new_thread(self.start_wbe_server, ('webserver', ))
# todo: polaczenie z gitlabem - nowy MR
self.mattermost_driver.login()
while True:
try:
self.mattermost_driver.init_websocket(self.socket_handler)
except Exception:
print('Reconnecting to websocket')
time.sleep(60)
def elaborate(self, platform: Platform) -> Module:
m = Module()
if platform:
clk_in = platform.request(platform.default_clk, dir='-')[0]
# Constants
pixel_f = self.timing.pixel_freq
hsync_front_porch = self.timing.h_front_porch
hsync_pulse_width = self.timing.h_sync_pulse
hsync_back_porch = self.timing.h_back_porch
vsync_front_porch = self.timing.v_front_porch
vsync_pulse_width = self.timing.v_sync_pulse
vsync_back_porch = self.timing.v_back_porch
# o_wifi_gpio0 = 1 keeps board from rebooting
# Hold btn0 to let ESP32 take control of the board.
m.d.comb += self.o_wifi_gpio0.eq(self.i_btn[0])
# Press btn0 to exit this bitstream.
R_delay_reload = Signal(20, reset=0)
with m.If(R_delay_reload[19] == 0):
m.d.sync += R_delay_reload.eq(R_delay_reload + 1)
m.d.comb += self.o_user_programn.eq((~self.i_btn[0])
| (~R_delay_reload[19]))
# Clock generator.
m.domains.sync = cd_sync = ClockDomain("sync")
m.domains.pixel = cd_pixel = ClockDomain("pixel")
m.domains.shift = cd_shift = ClockDomain("shift")
m.submodules.ecp5pll = pll = ECP5PLL()
pll.register_clkin(clk_in, platform.default_clk_frequency)
pll.create_clkout(cd_sync, platform.default_clk_frequency)
pll.create_clkout(cd_pixel, pixel_f)
pll.create_clkout(cd_shift,
pixel_f * 5.0 * (1.0 if self.ddr else 2.0))
platform.add_clock_constraint(cd_sync.clk,
platform.default_clk_frequency)
platform.add_clock_constraint(cd_pixel.clk, pixel_f)
platform.add_clock_constraint(
cd_shift.clk, pixel_f * 5.0 * (1.0 if self.ddr else 2.0))
# VGA signal generator.
vga_r = Signal(8)
vga_g = Signal(8)
vga_b = Signal(8)
vga_hsync = Signal()
vga_vsync = Signal()
vga_blank = Signal()
m.submodules.vga = vga = VGA(
resolution_x=self.timing.x,
hsync_front_porch=hsync_front_porch,
hsync_pulse=hsync_pulse_width,
hsync_back_porch=hsync_back_porch,
resolution_y=self.timing.y,
vsync_front_porch=vsync_front_porch,
vsync_pulse=vsync_pulse_width,
vsync_back_porch=vsync_back_porch,
bits_x=16, # Play around with the sizes because sometimes
bits_y=16 # a smaller/larger value will make it pass timing.
)
with m.If(vga.o_beam_y < 400):
m.d.comb += [vga.i_r.eq(0xff), vga.i_g.eq(0), vga.i_b.eq(0)]
with m.Else():
m.d.comb += [vga.i_r.eq(0), vga.i_g.eq(0xff), vga.i_b.eq(0)]
m.d.comb += [
vga.i_clk_en.eq(1),
vga.i_test_picture.eq(0),
vga_r.eq(vga.o_vga_r),
vga_g.eq(vga.o_vga_g),
vga_b.eq(vga.o_vga_b),
vga_hsync.eq(vga.o_vga_hsync),
vga_vsync.eq(vga.o_vga_vsync),
vga_blank.eq(vga.o_vga_blank),
]
# VGA to digital video converter.
tmds = [Signal(2) for i in range(4)]
m.submodules.vga2dvid = vga2dvid = VGA2DVID(
ddr=self.ddr, shift_clock_synchronizer=False)
m.d.comb += [
vga2dvid.i_red.eq(vga_r),
vga2dvid.i_green.eq(vga_g),
vga2dvid.i_blue.eq(vga_b),
vga2dvid.i_hsync.eq(vga_hsync),
vga2dvid.i_vsync.eq(vga_vsync),
vga2dvid.i_blank.eq(vga_blank),
tmds[3].eq(vga2dvid.o_clk),
tmds[2].eq(vga2dvid.o_red),
tmds[1].eq(vga2dvid.o_green),
tmds[0].eq(vga2dvid.o_blue),
]
# LED blinky
counter_width = 28
countblink = Signal(8)
m.submodules.blink = blink = Blink(counter_width)
m.d.comb += [
countblink.eq(blink.o_led),
self.o_led[6:8].eq(countblink[6:8]),
self.o_led[0].eq(vga_vsync),
self.o_led[1].eq(vga_hsync),
self.o_led[2].eq(vga_blank),
]
if (self.ddr):
# Vendor specific DDR modules.
# Convert SDR 2-bit input to DDR clocked 1-bit output (single-ended)
# onboard GPDI.
m.submodules.ddr0_clock = Instance("ODDRX1F",
i_SCLK=ClockSignal("shift"),
i_RST=0b0,
i_D0=tmds[3][0],
i_D1=tmds[3][1],
o_Q=self.o_gpdi_dp[3])
m.submodules.ddr0_red = Instance("ODDRX1F",
i_SCLK=ClockSignal("shift"),
i_RST=0b0,
i_D0=tmds[2][0],
i_D1=tmds[2][1],
o_Q=self.o_gpdi_dp[2])
m.submodules.ddr0_green = Instance("ODDRX1F",
i_SCLK=ClockSignal("shift"),
i_RST=0b0,
i_D0=tmds[1][0],
i_D1=tmds[1][1],
o_Q=self.o_gpdi_dp[1])
m.submodules.ddr0_blue = Instance("ODDRX1F",
i_SCLK=ClockSignal("shift"),
i_RST=0b0,
i_D0=tmds[0][0],
i_D1=tmds[0][1],
o_Q=self.o_gpdi_dp[0])
else:
m.d.comb += [
self.o_gpdi_dp[3].eq(tmds[3][0]),
self.o_gpdi_dp[2].eq(tmds[2][0]),
self.o_gpdi_dp[1].eq(tmds[1][0]),
self.o_gpdi_dp[0].eq(tmds[0][0]),
]
return m
import ubinascii
import time
import machine
from blink import Blink
from temperature import TemperatureSensor
from temperature_client import TemperatureClient
client_id = ubinascii.hexlify(machine.unique_id())
sensor = TemperatureSensor(5)
led = Blink(16)
tc = TemperatureClient(client_id, '93.80.147.216', 5, topic='esp/temp')
while True:
tc.publishTemperature()
print(str(time.localtime()) + ' | temp: ' + str(sensor.read_temp()))
led.blink(2, 0.2)
time.sleep(60)
def _test_health(self):
b = Blink()
print b.health()
def test_homescreen(self):
b = Blink()
data = b.homescreen()
self.assertTrue(data['account'] is not None)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/find')
def find():
json_dict = blink.find()
if json_dict is not None:
return jsonify(manufacturer=json_dict['bstick_man'],
description=json_dict['bstick_desc'],
serialNumber=json_dict['bstick_ser'],
color=json_dict['bstick_col'],
name=json_dict['bstick_name'],
info2=json_dict['bstick_info_2'])
else:
return '<Not Connected>'
@app.route('/blink')
def blink():
rgb_list = blink.blink()
return ','.join(str(i) for i in rgb_list)
if __name__ == '__main__':
blink = Blink()
app.run()
def test_events(self):
b = Blink()
b.connect()
events = b.events(b.networks[0])
self.assertEqual(type(events), list)
def test_cameras(self):
b = Blink()
b.connect()
cameras = b.cameras(b.networks[0])
self.assertEqual(type(cameras), list)
def test_download_video(self):
b = Blink()
b.connect()
events = b.events(b.networks[0])
event = events[0]
b.download_video(event)
class TestBlink(unittest.TestCase):
email = ""
password = ""
def setUp(self):
self.b = Blink(self.email, self.password)
self.b.login()
###############################################################################
## Highlighted Client APIs
###############################################################################
def test_login(self):
self.assertTrue(self.b.connected)
def test_homescreen(self):
data = self.b.homescreen()
self.assertTrue(data['account'] is not None)
self.assertTrue(data['network'] is not None)
for device in data['devices']:
if device['device_type'] is not None and device[
'device_type'] == "camera":
content, filename = self.b.download_thumbnail_home_v2(device)
blink.save_to_file(content, "home_" + filename)
def test_events_v2(self):
events = self.b.eventsv2()
self.assertEqual(type(events), list)
def test_video_count(self):
count = self.b.get_video_count()
print("video count = " + str(count))
def test_events_v2_download(self):
events = self.b.eventsv2()
if len(events) == 0:
return
event = events[0]
content = self.b.download_video_v2(event)
filename = self.b.get_event_name_v2(event)
blink.save_to_file(content, "event_" + filename)
def test_thumbnail_event_v2_download(self):
events = self.b.eventsv2()
if len(events) == 0:
return
event = events[0]
content = self.b.download_thumbnail_event_v2(event)
filename = self.b.get_thumbnail_name_event(event, "event")
f = open(filename, 'wb')
f.write(content)
f.close()
print('Save downloaded image to ' + filename)
###############################################################################
## Wrapped Functions
###############################################################################
def test_list_network_ids(self):
ids = self.b.list_network_ids()
self.assertEqual(type(ids), list)
def test_list_camera_ids(self):
ids = self.b.list_camera_ids()
self.assertEqual(type(ids), list)
def test_events_from_camera(self):
ids = self.b.list_camera_ids()
if len(ids) > 0:
id = ids[0]
events = self.b.events_from_camera(id, 1)
if len(events) > 0:
event = events[0]
content = self.b.download_video_v2(event)
filename = self.b.get_event_name_v2(event)
blink.save_to_file(content, "event_camera_" + filename)
def test_refresh_all_cameras_thumbnail(self):
self.b.refresh_all_cameras_thumbnail()
data = self.b.homescreen()
for device in data['devices']:
if device['device_type'] is not None and device[
'device_type'] == "camera":
content, filename = self.b.download_thumbnail_home_v2(device)
filename = "test_refresh_" + filename
blink.save_to_file(content, filename)
print("Download latest thumbnails to " + filename)
###############################################################################
## Other Client APIs
###############################################################################
def test_cameras(self):
cameras = self.b.cameras(self.b.networks[0])
self.assertEqual(type(cameras), list)
def test_clients(self):
clients = self.b.clients()
self.assertTrue(clients['clients'] is not None)
print(clients)
def test_sync_modules(self):
sync_modules = self.b.sync_modules(self.b.networks[0])
print(sync_modules)
def test_regions(self):
regions = self.b.regions()
print(regions)
def test_get_video_info(self):
events = self.b.eventsv2()
if len(events) == 0:
return
event = events[0]
eventinfo = self.b.get_video_info(event.id)
print("eventinfo:" + str(eventinfo))
def test_delete_video(self):
events = self.b.eventsv2(1000)
if len(events) == 0:
return
event = events[len(events) - 1]
suc = self.b.delete_video(event.id)
self.assertTrue(suc)
from umqtt.robust import MQTTClient
