jamie/ptulsconv
1
0
Fork 0
mirror of https://github.com/iluvcapra/ptulsconv.git synced 2025-12-31 08:50:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Updated unit tests

Browse Source
This commit is contained in:
Jamie Hardt
2021-06-02 11:06:18 -07:00
parent 8d4058d026
commit 24c5a87358
10 changed files with 165 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
ptulsconv/docparser/__init__.py
View File

@@ -1,25 +1 @@
from typing import Generator, Callable, Iterator from .doc_parser_visitor import parse_document
from enum import Enum
def apply_appends(source: Iterator,
should_append: Callable,
do_append: Callable) -> Generator:
"""
:param source:
:param should_append: Called with two variables a and b, your
function should return true if b should be
appended to a
:param do_append: Called with two variables a and b, your function
should return
:returns: A Generator
"""
this_element = next(source)
for element in source:
if should_append(this_element, element):
this_element = do_append(this_element, element)
else:
yield this_element
this_element = element
yield this_element

3
ptulsconv/docparser/doc_entity.py
View File

@@ -1,9 +1,6 @@
from fractions import Fraction from fractions import Fraction
from ptulsconv.broadcast_timecode import smpte_to_frame_count from ptulsconv.broadcast_timecode import smpte_to_frame_count
from typing import Tuple, List, Iterator from typing import Tuple, List, Iterator
from collections import namedtuple
from . import apply_appends
from .tagged_string_parser_visitor import parse_tags
class SessionDescriptor: class SessionDescriptor:

12
ptulsconv/docparser/doc_parser_visitor.py
View File

@@ -4,6 +4,18 @@ from .doc_entity import SessionDescriptor, HeaderDescriptor, TrackDescriptor, Fi
TrackClipDescriptor, ClipDescriptor, PluginDescriptor, MarkerDescriptor TrackClipDescriptor, ClipDescriptor, PluginDescriptor, MarkerDescriptor
def parse_document(path: str) -> SessionDescriptor:
"""
Parse a Pro Tools text export.
:param path: path to a file
:return: the session descriptor
"""
from .ptuls_grammar import protools_text_export_grammar
with open(path, 'r') as f:
ast = protools_text_export_grammar.parse(f.read())
return DocParserVisitor().visit(ast)
class DocParserVisitor(NodeVisitor): class DocParserVisitor(NodeVisitor):
@staticmethod @staticmethod

31
ptulsconv/docparser/tag_compiler.py
View File

@@ -1,10 +1,9 @@
from collections import namedtuple from collections import namedtuple
from fractions import Fraction from fractions import Fraction
from typing import Iterator, Tuple from typing import Iterator, Tuple, Callable, Generator
from ptulsconv.docparser import apply_appends import ptulsconv.docparser.doc_entity as doc_entity
from ptulsconv.docparser.doc_entity import SessionDescriptor from .tagged_string_parser_visitor import parse_tags, TagPreModes
from ptulsconv.docparser.tagged_string_parser_visitor import parse_tags, TagPreModes
class Event(namedtuple('Event', 'clip_name track_name session_name tags start finish')): class Event(namedtuple('Event', 'clip_name track_name session_name tags start finish')):
@@ -12,7 +11,7 @@ class Event(namedtuple('Event', 'clip_name track_name session_name tags start fi
class TagCompiler: class TagCompiler:
session: SessionDescriptor session: doc_entity.SessionDescriptor
def compile_events(self) -> Iterator[Event]: def compile_events(self) -> Iterator[Event]:
step0 = self.parse_data() step0 = self.parse_data()
@@ -121,3 +120,25 @@ class TagCompiler:
yield event.clip_content, event.track_content, session_parsed.content, tags, event.start, event.finish yield event.clip_content, event.track_content, session_parsed.content, tags, event.start, event.finish
def apply_appends(source: Iterator,
should_append: Callable,
do_append: Callable) -> Generator:
"""
:param source:
:param should_append: Called with two variables a and b, your
function should return true if b should be
appended to a
:param do_append: Called with two variables a and b, your function
should return
:returns: A Generator
"""
this_element = next(source)
for element in source:
if should_append(this_element, element):
this_element = do_append(this_element, element)
else:
yield this_element
this_element = element
yield this_element

148
tests/test_robinhood1.py
View File

@@ -1,6 +1,5 @@
import unittest import unittest
import ptulsconv from ptulsconv.docparser import parse_document
#import pprint
import os.path import os.path
@@ -8,102 +7,77 @@ class TestRobinHood1(unittest.TestCase):
path = os.path.dirname(__file__) + '/export_cases/Robin Hood Spotting.txt' path = os.path.dirname(__file__) + '/export_cases/Robin Hood Spotting.txt'
def test_header_export(self): def test_header_export(self):
with open(self.path, 'r') as f:
visitor = ptulsconv.DictionaryParserVisitor()
result = ptulsconv.protools_text_export_grammar.parse(f.read())
parsed: dict = visitor.visit(result)
self.assertTrue('header' in parsed.keys()) session = parse_document(self.path)
self.assertEqual(parsed['header']['session_name'], 'Robin Hood Spotting')
self.assertEqual(parsed['header']['sample_rate'], 48000.0) self.assertIsNotNone(session.header)
self.assertEqual(parsed['header']['bit_depth'], 24) self.assertEqual(session.header.session_name, 'Robin Hood Spotting')
self.assertEqual(parsed['header']['timecode_format'], 29.97) self.assertEqual(session.header.sample_rate, 48000.0)
self.assertEqual(parsed['header']['timecode_drop_frame'], False) self.assertEqual(session.header.bit_depth, 24)
self.assertEqual(session.header.timecode_format, '29.97')
self.assertEqual(session.header.timecode_drop_frame, False)
def test_all_sections(self): def test_all_sections(self):
with open(self.path, 'r') as f:
visitor = ptulsconv.DictionaryParserVisitor()
result = ptulsconv.protools_text_export_grammar.parse(f.read())
parsed: dict = visitor.visit(result)
self.assertIn('header', parsed.keys()) session = parse_document(self.path)
self.assertIn('files', parsed.keys())
self.assertIn('clips', parsed.keys()) self.assertIsNotNone(session.header)
self.assertIn('plugins', parsed.keys()) self.assertIsNotNone(session.files)
self.assertIn('tracks', parsed.keys()) self.assertIsNotNone(session.clips)
self.assertIn('markers', parsed.keys()) self.assertIsNotNone(session.plugins)
self.assertIsNotNone(session.tracks)
self.assertIsNotNone(session.markers)
def test_tracks(self): def test_tracks(self):
with open(self.path, 'r') as f:
visitor = ptulsconv.DictionaryParserVisitor() session = parse_document(self.path)
result = ptulsconv.protools_text_export_grammar.parse(f.read())
parsed: dict = visitor.visit(result) self.assertEqual(len(session.tracks), 14)
self.assertEqual(len(parsed['tracks']), 14) self.assertListEqual(["Scenes", "Robin", "Will", "Marian", "John",
self.assertListEqual(["Scenes", "Robin", "Will", "Marian", "John", "Guy", "Much", "Butcher", "Town Crier",
"Guy", "Much", "Butcher", "Town Crier", "Soldier 1", "Soldier 2", "Soldier 3",
"Soldier 1", "Soldier 2", "Soldier 3", "Priest", "Guest at Court"],
"Priest", "Guest at Court"], list(map(lambda t: t.name, session.tracks)))
list(map(lambda n: n['name'], parsed['tracks']))) self.assertListEqual(["", "[ADR] {Actor=Errol Flynn} $CN=1",
self.assertListEqual(["", "[ADR] {Actor=Errol Flynn} $CN=1", "[ADR] {Actor=Patrick Knowles} $CN=2",
"[ADR] {Actor=Patrick Knowles} $CN=2", "[ADR] {Actor=Olivia DeHavilland} $CN=3",
"[ADR] {Actor=Olivia DeHavilland} $CN=3", "[ADR] {Actor=Claude Raines} $CN=4",
"[ADR] {Actor=Claude Raines} $CN=4", "[ADR] {Actor=Basil Rathbone} $CN=5",
"[ADR] {Actor=Basil Rathbone} $CN=5", "[ADR] {Actor=Herbert Mundin} $CN=6",
"[ADR] {Actor=Herbert Mundin} $CN=6", "[ADR] {Actor=George Bunny} $CN=101",
"[ADR] {Actor=George Bunny} $CN=101", "[ADR] {Actor=Leonard Mundie} $CN=102",
"[ADR] {Actor=Leonard Mundie} $CN=102", "[ADR] $CN=103",
"[ADR] $CN=103", "[ADR] $CN=104",
"[ADR] $CN=104", "[ADR] $CN=105",
"[ADR] $CN=105", "[ADR] {Actor=Thomas R. Mills} $CN=106",
"[ADR] {Actor=Thomas R. Mills} $CN=106", "[ADR] $CN=107"],
"[ADR] $CN=107"], list(map(lambda t: t.comments, session.tracks)))
list(map(lambda n: n['comments'], parsed['tracks'])))
def test_a_track(self): def test_a_track(self):
with open(self.path, 'r') as f: session = parse_document(self.path)
visitor = ptulsconv.DictionaryParserVisitor() guy_track = session.tracks[5]
result = ptulsconv.protools_text_export_grammar.parse(f.read()) self.assertEqual(guy_track.name, 'Guy')
parsed: dict = visitor.visit(result) self.assertEqual(guy_track.comments, '[ADR] {Actor=Basil Rathbone} $CN=5')
guy_track = parsed['tracks'][5] self.assertEqual(guy_track.user_delay_samples, 0)
self.assertEqual(guy_track['name'], 'Guy') self.assertListEqual(guy_track.state, [])
self.assertEqual(guy_track['comments'], '[ADR] {Actor=Basil Rathbone} $CN=5') self.assertEqual(len(guy_track.clips), 16)
self.assertEqual(guy_track['user_delay_samples'], 0) self.assertEqual(guy_track.clips[5].channel, 1)
self.assertListEqual(guy_track['state'], []) self.assertEqual(guy_track.clips[5].event, 6)
self.assertEqual(len(guy_track['clips']), 16) self.assertEqual(guy_track.clips[5].clip_name, "\"What's your name? You Saxon dog!\" $QN=GY106")
self.assertEqual(guy_track['clips'][5]['channel'], 1) self.assertEqual(guy_track.clips[5].start_timecode, "01:04:19:15")
self.assertEqual(guy_track['clips'][5]['event'], 6) self.assertEqual(guy_track.clips[5].finish_timecode, "01:04:21:28")
self.assertEqual(guy_track['clips'][5]['clip_name'], "\"What's your name? You Saxon dog!\" $QN=GY106") self.assertEqual(guy_track.clips[5].duration, "00:00:02:13")
self.assertEqual(guy_track['clips'][5]['start_time'], "01:04:19:15") self.assertEqual(guy_track.clips[5].timestamp, None)
self.assertEqual(guy_track['clips'][5]['end_time'], "01:04:21:28") self.assertEqual(guy_track.clips[5].state, 'Unmuted')
self.assertEqual(guy_track['clips'][5]['duration'], "00:00:02:13")
self.assertEqual(guy_track['clips'][5]['timestamp'], None)
self.assertEqual(guy_track['clips'][5]['state'], 'Unmuted')
def test_memory_locations(self): def test_memory_locations(self):
with open(self.path, 'r') as f: session = parse_document(self.path)
visitor = ptulsconv.DictionaryParserVisitor()
result = ptulsconv.protools_text_export_grammar.parse(f.read())
parsed: dict = visitor.visit(result)
self.assertEqual(len(parsed['markers']),1)
self.assertEqual(parsed['markers'][0]['number'], 1)
self.assertEqual(parsed['markers'][0]['location'], "01:00:00:00")
self.assertEqual(parsed['markers'][0]['time_reference'], 0)
self.assertEqual(parsed['markers'][0]['units'], "Samples")
def test_transform_timecode(self):
parsed = dict()
with open(self.path, 'r') as f:
visitor = ptulsconv.DictionaryParserVisitor()
result = ptulsconv.protools_text_export_grammar.parse(f.read())
parsed = visitor.visit(result)
xformer = ptulsconv.TimecodeInterpreter()
xformer.apply_session_start = True
xformed = xformer.transform(parsed)
self.assertEqual(len(session.markers), 1)
self.assertEqual(session.markers[0].number, 1)
self.assertEqual(session.markers[0].location, "01:00:00:00")
self.assertEqual(session.markers[0].time_reference, 0)
self.assertEqual(session.markers[0].units, "Samples")
if __name__ == '__main__': if __name__ == '__main__':

64
tests/test_robinhood5.py
View File

@@ -1,5 +1,5 @@
import unittest import unittest
import ptulsconv from ptulsconv.docparser import parse_document
import os.path import os.path
@@ -7,50 +7,38 @@ class TestRobinHood5(unittest.TestCase):
path = os.path.dirname(__file__) + '/export_cases/Robin Hood Spotting5.txt' path = os.path.dirname(__file__) + '/export_cases/Robin Hood Spotting5.txt'
def test_skipped_segments(self): def test_skipped_segments(self):
with open(self.path, 'r') as f: session = parse_document(self.path)
visitor = ptulsconv.DictionaryParserVisitor() self.assertIsNone(session.files)
result = ptulsconv.protools_text_export_grammar.parse(f.read()) self.assertIsNone(session.clips)
parsed: dict = visitor.visit(result)
self.assertIsNone(parsed['files'])
self.assertIsNone(parsed['clips'])
def test_plugins(self): def test_plugins(self):
with open(self.path, 'r') as f: session = parse_document(self.path)
visitor = ptulsconv.DictionaryParserVisitor() self.assertEqual(len(session.plugins), 2)
result = ptulsconv.protools_text_export_grammar.parse(f.read())
parsed: dict = visitor.visit(result)
self.assertEqual(len(parsed['plugins']), 2)
def test_stereo_track(self): def test_stereo_track(self):
with open(self.path, 'r') as f: session = parse_document(self.path)
visitor = ptulsconv.DictionaryParserVisitor() self.assertEqual(session.tracks[1].name, 'MX WT (Stereo)')
result = ptulsconv.protools_text_export_grammar.parse(f.read()) self.assertEqual(len(session.tracks[1].clips), 2)
parsed: dict = visitor.visit(result) self.assertEqual(session.tracks[1].clips[0].clip_name, 'RobinHood.1-01.L')
self.assertEqual(parsed['tracks'][1]['name'], 'MX WT (Stereo)') self.assertEqual(session.tracks[1].clips[1].clip_name, 'RobinHood.1-01.R')
self.assertEqual(len(parsed['tracks'][1]['clips']), 2)
self.assertEqual(parsed['tracks'][1]['clips'][0]['clip_name'], 'RobinHood.1-01.L')
self.assertEqual(parsed['tracks'][1]['clips'][1]['clip_name'], 'RobinHood.1-01.R')
def test_a_track(self): def test_a_track(self):
with open(self.path, 'r') as f: session = parse_document(self.path)
visitor = ptulsconv.DictionaryParserVisitor()
result = ptulsconv.protools_text_export_grammar.parse(f.read())
parsed: dict = visitor.visit(result)
guy_track = parsed['tracks'][8] guy_track = session.tracks[8]
self.assertEqual(guy_track['name'], 'Guy') self.assertEqual(guy_track.name, 'Guy')
self.assertEqual(guy_track['comments'], '[ADR] {Actor=Basil Rathbone} $CN=5') self.assertEqual(guy_track.comments, '[ADR] {Actor=Basil Rathbone} $CN=5')
self.assertEqual(guy_track['user_delay_samples'], 0) self.assertEqual(guy_track.user_delay_samples, 0)
self.assertListEqual(guy_track['state'], ['Solo']) self.assertListEqual(guy_track.state, ['Solo'])
self.assertEqual(len(guy_track['clips']), 16) self.assertEqual(len(guy_track.clips), 16)
self.assertEqual(guy_track['clips'][5]['channel'], 1) self.assertEqual(guy_track.clips[5].channel, 1)
self.assertEqual(guy_track['clips'][5]['event'], 6) self.assertEqual(guy_track.clips[5].event, 6)
self.assertEqual(guy_track['clips'][5]['clip_name'], "\"What's your name? You Saxon dog!\" $QN=GY106") self.assertEqual(guy_track.clips[5].clip_name, "\"What's your name? You Saxon dog!\" $QN=GY106")
self.assertEqual(guy_track['clips'][5]['start_time'], "01:04:19:15.00") self.assertEqual(guy_track.clips[5].start_timecode, "01:04:19:15.00")
self.assertEqual(guy_track['clips'][5]['end_time'], "01:04:21:28.00") self.assertEqual(guy_track.clips[5].finish_timecode, "01:04:21:28.00")
self.assertEqual(guy_track['clips'][5]['duration'], "00:00:02:13.00") self.assertEqual(guy_track.clips[5].duration, "00:00:02:13.00")
self.assertEqual(guy_track['clips'][5]['timestamp'], "01:04:19:09.70") self.assertEqual(guy_track.clips[5].timestamp, "01:04:19:09.70")
self.assertEqual(guy_track['clips'][5]['state'], 'Unmuted') self.assertEqual(guy_track.clips[5].state, 'Unmuted')
if __name__ == '__main__': if __name__ == '__main__':

39
tests/test_robinhood6.py
View File

@@ -1,5 +1,5 @@
import unittest import unittest
import ptulsconv from ptulsconv.docparser import parse_document
import os.path import os.path
@@ -7,25 +7,24 @@ class TestRobinHood6(unittest.TestCase):
path = os.path.dirname(__file__) + '/export_cases/Robin Hood Spotting6.txt' path = os.path.dirname(__file__) + '/export_cases/Robin Hood Spotting6.txt'
def test_a_track(self): def test_a_track(self):
with open(self.path, 'r') as f: session = parse_document(self.path)
visitor = ptulsconv.DictionaryParserVisitor()
result = ptulsconv.protools_text_export_grammar.parse(f.read()) marian_track = session.tracks[6]
parsed: dict = visitor.visit(result) self.assertEqual(marian_track.name, 'Marian')
marian_track = parsed['tracks'][6] self.assertEqual(marian_track.comments, '[ADR] {Actor=Olivia DeHavilland} $CN=3')
self.assertEqual(marian_track['name'], 'Marian') self.assertEqual(marian_track.user_delay_samples, 0)
self.assertEqual(marian_track['comments'], '[ADR] {Actor=Olivia DeHavilland} $CN=3') self.assertListEqual(marian_track.state, ['Solo'])
self.assertEqual(marian_track['user_delay_samples'], 0) self.assertEqual(len(marian_track.clips), 4)
self.assertListEqual(marian_track['state'], ['Solo']) self.assertListEqual(marian_track.plugins, ['Channel Strip (mono)', 'ReVibe II (mono/5.1)'])
self.assertEqual(len(marian_track['clips']), 4) self.assertEqual(marian_track.clips[2].channel, 1)
self.assertListEqual(marian_track['plugins'], ['Channel Strip (mono)', 'ReVibe II (mono/5.1)']) self.assertEqual(marian_track.clips[2].event, 3)
self.assertEqual(marian_track['clips'][2]['channel'], 1) self.assertEqual(marian_track.clips[2].clip_name,
self.assertEqual(marian_track['clips'][2]['event'], 3) "\"Isn't that reason enough for a Royal Ward who must obey her guardian?\" $QN=M103")
self.assertEqual(marian_track['clips'][2]['clip_name'], "\"Isn't that reason enough for a Royal Ward who must obey her guardian?\" $QN=M103") self.assertEqual(marian_track.clips[2].start_timecode, "01:08:01:11")
self.assertEqual(marian_track['clips'][2]['start_time'], "01:08:01:11") self.assertEqual(marian_track.clips[2].finish_timecode, "01:08:04:24")
self.assertEqual(marian_track['clips'][2]['end_time'], "01:08:04:24") self.assertEqual(marian_track.clips[2].duration, "00:00:03:12")
self.assertEqual(marian_track['clips'][2]['duration'], "00:00:03:12") self.assertEqual(marian_track.clips[2].timestamp, "01:08:01:11")
self.assertEqual(marian_track['clips'][2]['timestamp'], "01:08:01:11") self.assertEqual(marian_track.clips[2].state, 'Unmuted')
self.assertEqual(marian_track['clips'][2]['state'], 'Unmuted')
if __name__ == '__main__': if __name__ == '__main__':

45
tests/test_robinhooddf.py
View File

@@ -1,5 +1,5 @@
import unittest import unittest
import ptulsconv from ptulsconv.docparser import parse_document
import os.path import os.path
@@ -7,30 +7,23 @@ class TestRobinHoodDF(unittest.TestCase):
path = os.path.dirname(__file__) + '/export_cases/Robin Hood SpottingDF.txt' path = os.path.dirname(__file__) + '/export_cases/Robin Hood SpottingDF.txt'
def test_header_export_df(self): def test_header_export_df(self):
with open(self.path, 'r') as f: session = parse_document(self.path)
visitor = ptulsconv.DictionaryParserVisitor() self.assertEqual(session.header.timecode_drop_frame, True)
result = ptulsconv.protools_text_export_grammar.parse(f.read())
parsed: dict = visitor.visit(result)
self.assertTrue('header' in parsed.keys())
self.assertEqual(parsed['header']['timecode_drop_frame'], True)
def test_a_track(self): def test_a_track(self):
with open(self.path, 'r') as f: session = parse_document(self.path)
visitor = ptulsconv.DictionaryParserVisitor()
result = ptulsconv.protools_text_export_grammar.parse(f.read()) guy_track = session.tracks[4]
parsed: dict = visitor.visit(result) self.assertEqual(guy_track.name, 'Robin')
guy_track = parsed['tracks'][4] self.assertEqual(guy_track.comments, '[ADR] {Actor=Errol Flynn} $CN=1')
self.assertEqual(guy_track['name'], 'Robin') self.assertEqual(guy_track.user_delay_samples, 0)
self.assertEqual(guy_track['comments'], '[ADR] {Actor=Errol Flynn} $CN=1') self.assertListEqual(guy_track.state, [])
self.assertEqual(guy_track['user_delay_samples'], 0) self.assertEqual(len(guy_track.clips), 10)
self.assertListEqual(guy_track['state'], []) self.assertEqual(guy_track.clips[5].channel, 1)
self.assertEqual(len(guy_track['clips']), 10) self.assertEqual(guy_track.clips[5].event, 6)
self.assertEqual(guy_track['clips'][5]['channel'], 1) self.assertEqual(guy_track.clips[5].clip_name, "\"Hold there! What's his fault?\" $QN=R106")
self.assertEqual(guy_track['clips'][5]['event'], 6) self.assertEqual(guy_track.clips[5].start_timecode, "01:05:30;15")
self.assertEqual(guy_track['clips'][5]['clip_name'], "\"Hold there! What's his fault?\" $QN=R106") self.assertEqual(guy_track.clips[5].finish_timecode, "01:05:32;01")
self.assertEqual(guy_track['clips'][5]['start_time'], "01:05:30;15") self.assertEqual(guy_track.clips[5].duration, "00:00:01;16")
self.assertEqual(guy_track['clips'][5]['end_time'], "01:05:32;01") self.assertEqual(guy_track.clips[5].timestamp, None)
self.assertEqual(guy_track['clips'][5]['duration'], "00:00:01;16") self.assertEqual(guy_track.clips[5].state, 'Unmuted')
self.assertEqual(guy_track['clips'][5]['timestamp'], None)
self.assertEqual(guy_track['clips'][5]['state'], 'Unmuted')

1
tests/test_tag_interpreter.py
View File

@@ -1,6 +1,5 @@
import unittest import unittest
from ptulsconv.docparser.tagged_string_parser_visitor import parse_tags, TagPreModes from ptulsconv.docparser.tagged_string_parser_visitor import parse_tags, TagPreModes

2
tests/test_utils.py
View File

@@ -1,6 +1,6 @@
import unittest import unittest
from ptulsconv.docparser import apply_appends from ptulsconv.docparser.tag_compiler import apply_appends
class MyTestCase(unittest.TestCase): class MyTestCase(unittest.TestCase):