class TestTagRemoval(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_italics_tag(self):
self.item.text = "<i>Hello world !</i>"
self.assertEqual(self.item.text_without_tags,'Hello world !')
def test_bold_tag(self):
self.item.text = "<b>Hello world !</b>"
self.assertEqual(self.item.text_without_tags,'Hello world !')
def test_underline_tag(self):
self.item.text = "<u>Hello world !</u>"
self.assertEqual(self.item.text_without_tags,'Hello world !')
def test_color_tag(self):
self.item.text = '<font color="#ff0000">Hello world !</font>'
self.assertEqual(self.item.text_without_tags,'Hello world !')
def test_all_tags(self):
self.item.text = '<b>Bold</b>, <i>italic</i>, <u>underlined</u>\n' + \
'<font color="#ff0000">red text</font>' + \
', <b>one,<i> two,<u> three</u></i></b>.'
self.assertEqual(self.item.text_without_tags,'Bold, italic, underlined' + \
'\nred text, one, two, three.')
class TestTagRemoval(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_italics_tag(self):
self.item.text = "<i>Hello world !</i>"
self.assertEqual(self.item.text_without_tags, 'Hello world !')
def test_bold_tag(self):
self.item.text = "<b>Hello world !</b>"
self.assertEqual(self.item.text_without_tags, 'Hello world !')
def test_underline_tag(self):
self.item.text = "<u>Hello world !</u>"
self.assertEqual(self.item.text_without_tags, 'Hello world !')
def test_color_tag(self):
self.item.text = '<font color="#ff0000">Hello world !</font>'
self.assertEqual(self.item.text_without_tags, 'Hello world !')
def test_all_tags(self):
self.item.text = '<b>Bold</b>, <i>italic</i>, <u>underlined</u>\n' + \
'<font color="#ff0000">red text</font>' + \
', <b>one,<i> two,<u> three</u></i></b>.'
self.assertEqual(self.item.text_without_tags,'Bold, italic, underlined' + \
'\nred text, one, two, three.')
class TestShifting(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_shift_up(self):
self.item.shift(1, 2, 3, 4)
self.assertEqual(self.item.start, (1, 3, 3, 4))
self.assertEqual(self.item.end, (1, 3, 23, 4))
self.assertEqual(self.item.duration, (0, 0, 20, 0))
self.assertEqual(self.item.characters_per_second, 0.65)
def test_shift_down(self):
self.item.shift(5)
self.item.shift(-1, -2, -3, -4)
self.assertEqual(self.item.start, (3, 58, 56, 996))
self.assertEqual(self.item.end, (3, 59, 16, 996))
self.assertEqual(self.item.duration, (0, 0, 20, 0))
self.assertEqual(self.item.characters_per_second, 0.65)
def test_shift_by_ratio(self):
self.item.shift(ratio=2)
self.assertEqual(self.item.start, {'minutes': 2})
self.assertEqual(self.item.end, {'minutes': 2, 'seconds': 40})
self.assertEqual(self.item.duration, (0, 0, 40, 0))
self.assertEqual(self.item.characters_per_second, 0.325)
class TestShifting(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_shift_up(self):
self.item.shift(1, 2, 3, 4)
self.assertEqual(self.item.start, (1, 3, 3, 4))
self.assertEqual(self.item.end, (1, 3, 23, 4))
self.assertEqual(self.item.duration, (0, 0, 20, 0))
self.assertEqual(self.item.characters_per_second, 0.65)
def test_shift_down(self):
self.item.shift(5)
self.item.shift(-1, -2, -3, -4)
self.assertEqual(self.item.start, (3, 58, 56, 996))
self.assertEqual(self.item.end, (3, 59, 16, 996))
self.assertEqual(self.item.duration, (0, 0, 20, 0))
self.assertEqual(self.item.characters_per_second, 0.65)
def test_shift_by_ratio(self):
self.item.shift(ratio=2)
self.assertEqual(self.item.start, {'minutes': 2})
self.assertEqual(self.item.end, {'minutes': 2, 'seconds': 40})
self.assertEqual(self.item.duration, (0, 0, 40, 0))
self.assertEqual(self.item.characters_per_second, 0.325)
class TestSerialAndParsing(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
self.string = u'1\n00:01:00,000 --> 00:01:20,000\nHello world !\n'
self.bad_string = u'foobar'
self.coordinates = (u'1\n00:01:00,000 --> 00:01:20,000 X1:000 X2:000 '
'Y1:050 Y2:100\nHello world !\n')
self.vtt = (u'1\n00:01:00,000 --> 00:01:20,000 D:vertical A:start '
'L:12%\nHello world !\n')
self.dots = u'1\n00:01:00.000 --> 00:01:20.000\nHello world !\n'
self.string_index = u'foo\n00:01:00,000 --> 00:01:20,000\nHello !\n'
self.no_index = u'00:01:00,000 --> 00:01:20,000\nHello world !\n'
def test_serialization(self):
self.assertEqual(unicode(self.item), self.string)
def test_from_string(self):
self.assertEquals(SubRipItem.from_string(self.string), self.item)
self.assertRaises(InvalidItem, SubRipItem.from_string,
self.bad_string)
def test_coordinates(self):
item = SubRipItem.from_string(self.coordinates)
self.assertEquals(item, self.item)
self.assertEquals(item.position, 'X1:000 X2:000 Y1:050 Y2:100')
def test_vtt_positioning(self):
vtt = SubRipItem.from_string(self.vtt)
self.assertEquals(vtt.position, 'D:vertical A:start L:12%')
self.assertEquals(vtt.index, 1)
self.assertEquals(vtt.text, 'Hello world !')
def test_idempotence(self):
vtt = SubRipItem.from_string(self.vtt)
self.assertEquals(unicode(vtt), self.vtt)
item = SubRipItem.from_string(self.coordinates)
self.assertEquals(unicode(item), self.coordinates)
def test_dots(self):
self.assertEquals(SubRipItem.from_string(self.dots), self.item)
# Bug reported in https://github.com/byroot/pysrt/issues/16
def test_paring_error(self):
self.assertRaises(InvalidItem, SubRipItem.from_string, u'1\n'
'00:01:00,000 -> 00:01:20,000 X1:000 X2:000 '
'Y1:050 Y2:100\nHello world !\n')
def test_string_index(self):
item = SubRipItem.from_string(self.string_index)
self.assertEquals(item.index, 'foo')
self.assertEquals(item.text, 'Hello !')
def test_no_index(self):
item = SubRipItem.from_string(self.no_index)
self.assertEquals(item.index, None)
self.assertEquals(item.text, 'Hello world !')
class TestOperators(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_cmp(self):
self.assertEqual(self.item, self.item)
class TestDuration(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_duration(self):
self.assertEqual(self.item.duration, (0, 0, 20, 0))
class TestDuration(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_duration(self):
self.assertEqual(self.item.duration, (0, 0, 20, 0))
class TestOperators(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_cmp(self):
self.assertEquals(self.item, self.item)
class TestCPS(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_characters_per_second(self):
self.assertEqual(self.item.characters_per_second, 0.65)
def test_text_change(self):
self.item.text = "Hello world !\nHello world again !"
self.assertEqual(self.item.characters_per_second, 1.6)
class TestSerialAndParsing(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
self.string = u'1\n00:01:00,000 --> 00:01:20,000\nHello world !\n'
self.bad_string = u'foobar'
self.coordinates = (u'1\n00:01:00,000 --> 00:01:20,000 X1:000 X2:000 '
'Y1:050 Y2:100\nHello world !\n')
self.vtt = (u'1\n00:01:00,000 --> 00:01:20,000 D:vertical A:start '
'L:12%\nHello world !\n')
self.dots = u'1\n00:01:00.000 --> 00:01:20.000\nHello world !\n'
self.bad_index = u'foo\n00:01:00,000 --> 00:01:20,000\nHello !\n'
def test_serialization(self):
self.assertEqual(unicode(self.item), self.string)
def test_from_string(self):
self.assertEquals(SubRipItem.from_string(self.string), self.item)
self.assertRaises(InvalidItem, SubRipItem.from_string,
self.bad_string)
def test_coordinates(self):
item = SubRipItem.from_string(self.coordinates)
self.assertEquals(item, self.item)
self.assertEquals(item.position, 'X1:000 X2:000 Y1:050 Y2:100')
def test_vtt_positioning(self):
vtt = SubRipItem.from_string(self.vtt)
self.assertEquals(vtt.position, 'D:vertical A:start L:12%')
self.assertEquals(vtt.index, 1)
self.assertEquals(vtt.text, 'Hello world !')
def test_idempotence(self):
vtt = SubRipItem.from_string(self.vtt)
self.assertEquals(unicode(vtt), self.vtt)
item = SubRipItem.from_string(self.coordinates)
self.assertEquals(unicode(item), self.coordinates)
def test_dots(self):
self.assertEquals(SubRipItem.from_string(self.dots), self.item)
# Bug reported in https://github.com/byroot/pysrt/issues/16
def test_paring_error(self):
self.assertRaises(InvalidItem, SubRipItem.from_string, u'1\n'
'00:01:00,000 -> 00:01:20,000 X1:000 X2:000 '
'Y1:050 Y2:100\nHello world !\n')
def test_invalid_index(self):
self.assertRaises(InvalidItem, SubRipItem.from_string, self.bad_index)
def dmxread_callback(frame, frame_no):
global prevFrame, prevTime, subs, srtFile
# if prevFrame. == 0:
# prevFrame = array(frame)
frameArray = array(frame)
if not array_equal(prevFrame,frameArray):
if frame != None:
item = SubRipItem(1, text="DMX1"+str(frame))
item.shift(seconds=prevTime)
item.end.shift(seconds=perf_counter()-prevTime)
if VERBOSE:
print(item)
subs.append(item)
srtFile.append(item)
prevTime = perf_counter()
prevFrame = array(frame)
def play_record_dmx(unused_addr, args, value):
global INTERVAL, TRANSITION_TIME, previous_time, dmxCounter, VERBOSE
global prev_frame, prev_time, subs, srtFile, previous_dmx_time, DMX_INTERVAL, sub_incr
global dmx
dmx_array[int(args[0])] = int(value * 255)
current_dmx_time = time.time()
elapsed_dmx_time = current_dmx_time - previous_dmx_time
if DEBUG:
print("DMX time", current_dmx_time, previous_dmx_time,
elapsed_dmx_time)
if (elapsed_dmx_time > DMX_INTERVAL):
frameArray = trim_zeros(dmx_array, 'b').astype('uint8')
# frameArray = array(frameArray)
print(array_equal(prev_frame, frameArray), tuple(prev_frame),
tuple(frameArray))
if not array_equal(prev_frame, frameArray):
if frameArray.any() != None:
item = SubRipItem(sub_incr,
text="DMX1" +
str(tuple(frameArray)[1:]).replace(" ", ""))
item.shift(seconds=prev_time)
item.end.shift(seconds=perf_counter() - prev_time)
if VERBOSE:
print(item)
subs.append(item)
if srtFile != None:
srtFile.append(item)
# encoding="utf_8"
# srtFile.save(SRT_FILENAME, encoding=encoding)
sub_incr += 1
prev_time = perf_counter()
if PLAY_DMX:
if DEBUG:
print("DMX tuple", tuple(frameArray)[1:])
dmx.write_frame(tuple(frameArray)[1:])
if not array_equal(prev_frame, frameArray):
prev_frame = frameArray
previous_dmx_time = time.time()
print(previous_dmx_time)
class TestCPS(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_characters_per_second(self):
self.assertEqual(self.item.characters_per_second, 0.65)
def test_text_change(self):
self.item.text = "Hello world !\nHello world again !"
self.assertEqual(self.item.characters_per_second, 1.6)
def test_zero_duration(self):
self.item.start.shift(seconds=20)
self.assertEqual(self.item.characters_per_second, 0.0)
def test_tags(self):
self.item.text = '<b>bold</b>, <i>italic</i>, <u>underlined</u>\n' + \
'<font color="#ff0000">red text</font>' + \
', <b>one,<i> two,<u> three</u></i></b>'
self.assertEqual(self.item.characters_per_second, 2.45)
class TestCPS(unittest.TestCase):
def setUp(self):
self.item = SubRipItem(1, text="Hello world !")
self.item.shift(minutes=1)
self.item.end.shift(seconds=20)
def test_characters_per_second(self):
self.assertEqual(self.item.characters_per_second, 0.65)
def test_text_change(self):
self.item.text = "Hello world !\nHello world again !"
self.assertEqual(self.item.characters_per_second, 1.6)
def test_zero_duration(self):
self.item.start.shift(seconds = 20)
self.assertEqual(self.item.characters_per_second, 0.0)
def test_tags(self):
self.item.text = '<b>bold</b>, <i>italic</i>, <u>underlined</u>\n' + \
'<font color="#ff0000">red text</font>' + \
', <b>one,<i> two,<u> three</u></i></b>'
self.assertEqual(self.item.characters_per_second, 2.45)
def play_record_hue(address: str, *args: List[Any]) -> None:
global bridge, INTERVAL, TRANSITION_TIME, previous_time, hue_list, hue_cmds, RECORD, VERBOSE, MAX_BRIGHTNESS
global prev_time, subs, srtFile, sub_incr, prev_cmds_str
# print(hue_list)
#print(len(args))
#if not len(args) == 4 or type(args[0]) is not float or type(args[1]) is not float:
# return
if DEBUG:
print(len(args), args)
# Check that address starts with filter
#if not address[:-1] == "/hue": # Cut off the last character
# return
r = args[1]
g = args[2]
b = args[3]
h, s, v = rgb_to_hsv(r, g, b)
h *= 65535.0
s *= 254.0
v *= 254.0
h = int(h)
s = int(s)
v = int(v * MAX_BRIGHTNESS / 254.0)
# hue_n = args[0][0][-1]
hue_n = int(args[0][0])
print(hue_n, len(hue_list), hue_list)
on = True
if v <= 1:
on = False
cmd = {
'transitiontime': int(TRANSITION_TIME),
'on': on,
'bri': int(v),
'sat': int(s),
'hue': int(h)
}
if len(hue_cmds) < hue_n:
hue_cmds.append(cmd)
else:
hue_cmds[hue_n - 1] = cmd
if int(hue_n) < len(hue_list) or not PLAY_HUE:
# print(hue_n,hue_list[int(hue_n)],h,s,v)
current_time = time.time()
elapsed_time = current_time - previous_time
if DEBUG:
print("HUE time", current_time, previous_time, elapsed_time)
# print(cmd, hue_list,hue_list[int(hue_n)])
if (elapsed_time > INTERVAL):
# if True:
if PLAY_HUE:
for hl in hue_list[int(hue_n)]:
if DEBUG:
print("---", hue_n, hl, h, s, v)
l = (h, s, v, int(TRANSITION_TIME))
bridge.set_light(hl, cmd)
cmds_str = ""
if DEBUG:
print(hue_cmds)
i = 0
for c in hue_cmds:
l = (hue_cmds[i]["hue"], hue_cmds[i]["sat"],
hue_cmds[i]["bri"], hue_cmds[i]["transitiontime"])
if cmds_str == "":
cmds_str += "HUE" + str(i + 1) + str(l).replace(" ", "")
else:
cmds_str += ";HUE" + str(i + 1) + str(l).replace(" ", "")
i += 1
if cmds_str != prev_cmds_str:
item = SubRipItem(sub_incr, text=cmds_str)
item.shift(seconds=prev_time)
item.end.shift(seconds=perf_counter() - prev_time)
# item.end.shift(seconds=prev_time+int(TRANSITION_TIME)/10.0)
if VERBOSE:
print("---", item)
subs.append(item)
if srtFile != None:
srtFile.append(item)
encoding = "utf_8"
srtFile.save(SRT_FILENAME, encoding=encoding)
sub_incr += 1
prev_cmds_str = cmds_str
prev_time = perf_counter()
# bridge.set_light(int(hue_n), cmd)
previous_time = time.time()
if DEBUG:
print("Hue commands", hue_cmds)
def handle_tracks(tracks, start, end, fps, srt_filename):
global XML_FILENAME, HUE_SAMPLING, DMX_SAMPLING, TRANSITION_TIME, DEBUG, VERBOSE
track_list = []
for track in tracks:
track_list = handle_track_list(track, start, end, fps)
# print(track_list[3][0])
# try:
# print(len(track_list[3]),len(track_list[3][0]),track_list[3][0][1:10],track_list[3][-1][1:10])
# except:
# pass
# srt_file = open(srt_filename,"w")
dmx_frame = zeros(512)
prev_dmx_frame = zeros(512)
prev_dmx_valid_frame = zeros(512)
subrip_file = SubRipFile(path=srt_filename)
print(40 * "-")
print("Processing frames")
print(40 * "-")
# print(track_list[3][1])
# print(len(track_list[1]))
if len(track_list[1]) > 0:
# If there isn't only an audio track
# print(track_list[1][0])
# print(track_list[1][0]!="audio")
# print(len(track_list[1]) != 1 and track_list[1][0]!="audio")
if (len(track_list[1]) != 1 or track_list[1][0] != "audio"):
print("Number of lighting events: ", len(track_list[3][0]))
frame_no = 0
for i in range(len(track_list[3][0])):
# frame_no = track_list[4][i]
frame_no = i
t = i * (1.0 / float(fps))
if VERBOSE:
print(40 * "-")
# print(frame_no,fps)
print("Frame %s / time %s seconds" % (frame_no, t))
print(40 * "-")
hue_cmd = ""
dmx_cmd = ""
# for the bug, len(of track_list[0]) is greater than
# len(track_list[3])
for j in range(len(track_list[0])):
# print(track_list[1][j])
if track_list[1][j] != "audio":
name = track_list[0][j]
type = track_list[1][j]
addr = track_list[2][j]
# print(name,type,addr)
# TODO: if frame_no = i as on line 181, the following line fails!
# [3][j] is out of range therefore j is the problem
try:
payload = track_list[3][j][i]
except Exception as e:
print(
'ERROR: could not get payload, len(of track_list[0]) is likely greater than \
len (track_list[3])')
# print(name, type, addr, payload)
# Convert Hue payload to hue command
if payload != "":
if addr[1:4].lower(
) == "hue" and type == "OSCColor/floatarray":
if VERBOSE:
print("hue", addr, payload)
r, g, b, a = 0, 0, 0, 0
try:
payload_list = payload.split(",")
# print(payload_list)
if len(payload_list) == 3:
r, g, b = payload_list
elif len(payload_list) == 4:
r, g, b, a = payload_list
except Exception as e:
print(e)
h, s, v = rgb_to_hsv(float(r), float(g),
float(b))
h *= 65535.0
s *= 254.0
v *= 254.0
h = int(h)
s = int(s)
v = int(v)
# print("hue", addr, payload, h,s,v)
n = int(addr[4:])
# print("hue", n, h,s,v)
if len(hue_cmd) == 0:
hue_cmd += "HUE%s(%s,%s,%s,%s)" % (
n, h, s, v, TRANSITION_TIME)
else:
hue_cmd += ";HUE%s(%s,%s,%s,%s)" % (
n, h, s, v, TRANSITION_TIME)
# Convert single DMX channel to command
elif addr[1:4].lower(
) == "dmx" and type == "OSCValue/float":
if VERBOSE:
print("dmx value", addr, payload)
n = int(addr[4:])
if payload != "":
dmx_frame[int(n)] = int(
float(payload) * 254)
# Convert multiple DMX channels to command
elif addr[1:4].lower() == "dmx" and (
type == "OSCColor/floatarray"
or type == "OSCValue/standard"):
if VERBOSE:
print("dmx colour", addr, payload)
n = int(addr[4:])
if payload != "":
payload_list = payload.split(",")
for channel in payload_list:
dmx_frame[int(n)] = int(
float(channel) * 254)
n += 1
# Output HUE commands
# hue_t = frame_no * (1.0/HUE_SAMPLING)
if frame_no % fps == 0 and hue_cmd != "":
item = SubRipItem(frame_no, text=hue_cmd)
item.shift(seconds=t)
item.end.shift(seconds=1)
if VERBOSE:
print(item)
else:
print("h", end="")
stdout.flush()
subrip_file.append(item)
frame_no += 1
# Output DMX command
dmx_frame_trimmed = trim_zeros(dmx_frame, 'b').astype('uint8')
# print("dmx_frame_trimmed before",dmx_frame_trimmed)
# if len(dmx_frame_trimmed)==0:
# dmx_frame_trimmed = zeros(512)
# print("dmx_frame_trimmed after",dmx_frame_trimmed)
dmx_cmd = "DMX1" + str(tuple(dmx_frame_trimmed)[1:]).replace(
" ", "")
if VERBOSE:
print('dmx_cmd to be written: ', dmx_cmd)
# cmd = hue_cmd + ";" + dmx_cmd
if (not array_equal(dmx_frame_trimmed,
prev_dmx_frame)) or (frame_no % fps == 0):
# if frame_no % fps == 0 and dmx_cmd=="":
# if frame_no % fps == 0:
# print(dmx_cmd, prev_dmx_frame)
# Fix for and empty DMX command
# Usually found at the start of a treatment track
if dmx_cmd == "DMX1()":
item = dmx_cmd = "DMX1" + str(
tuple(zeros(512, dtype=int))[1:]).replace(" ", "")
item = SubRipItem(frame_no, text=dmx_cmd)
item.shift(seconds=t)
item.end.shift(seconds=1.0 / fps)
if VERBOSE:
print(item)
else:
print("d", end="")
stdout.flush()
subrip_file.append(item)
frame_no += 1
prev_dmx_frame = dmx_frame_trimmed
# print(cmd)
if VERBOSE:
print(40 * "-")
# print(track_list[0][j], track_list[1][j], track_list[2][j], track_list[3][j][i])
# print(frame)
# j = 1
# for frame in track:
# print(track_list[0][i] + " " +frame, end = " ")
# j += 1
# print()
encoding = "utf_8"
subrip_file.save(srt_filename, encoding=encoding)
print()
