Implementation

ptulsconv/docparser/adr_entity.py

@@ -1,4 +1,5 @@
 from .doc_entity import SessionDescriptor, TrackDescriptor, TrackClipDescriptor
+from .tag_compiler import Event
 from typing import Optional, Generator
 
 # field_map maps tags in the text export to fields in FMPXMLRESULT
@@ -72,7 +73,7 @@ class ADRLine:
     adlib: bool
     optional: bool
 
-    adr_tag_to_line_map = (
+    adr_tag_to_line_map = [
         TagMapping(source='Title', target="title", alt=TagMapping.ContentSource.Session),
         TagMapping(source="Supv", target="supervisor"),
         TagMapping(source="Client", target="client"),
@@ -104,18 +105,12 @@ class ADRLine:
                    formatter=(lambda x: len(x) > 0)),
         TagMapping(source="OPT", target="optional",
                    formatter=(lambda x: len(x) > 0))
-    )
+    ]
 
-    @staticmethod
-    def from_clip(clip: TrackClipDescriptor,
-                  track: TrackDescriptor,
-                  session: SessionDescriptor) -> Optional['ADRLine']:
-        pass
+    @classmethod
+    def from_event(cls, event: Event) -> Optional['ADRLine']:
+        new = cls()
+        TagMapping.apply_rules(cls.adr_tag_to_line_map, event.tags,
+                               event.clip_name, event.track_name, event.session_name, new)
+        return new
 
-    @staticmethod
-    def generate_lines(session: SessionDescriptor) -> Generator['ADRLine']:
-        for track in session.tracks:
-            for track_clip in track.clips:
-                line = ADRLine.from_clip(track_clip, track, session)
-                if line is not None:
-                    yield line

ptulsconv/docparser/tag_compiler.py

@@ -4,10 +4,13 @@ from typing import Iterator, Tuple
 
 from ptulsconv.docparser import apply_appends
 from ptulsconv.docparser.doc_entity import SessionDescriptor
-from ptulsconv.docparser.tag_mapping import Event
 from ptulsconv.docparser.tagged_string_parser_visitor import parse_tags, TagPreModes
 
 
+class Event(namedtuple('Event', 'clip_name track_name session_name tags start finish')):
+    pass
+
+
 class TagCompiler:
     session: SessionDescriptor
 
@@ -116,4 +119,5 @@ class TagCompiler:
                                        marker_tags=marker_tags,
                                        session_tags=session_parsed.tag_dict)
 
-            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
+

ptulsconv/docparser/tag_mapping.py

@@ -1,10 +1,5 @@
 from enum import Enum
 from typing import Optional, Callable, Any, List
-from collections import namedtuple
-
-
-class Event(namedtuple('Event', 'clip_name track_name session_name tags start finish')):
-    pass
 
 
 class TagMapping:

ptulsconv/docparser/tagged_string_parser_visitor.py

@@ -36,7 +36,7 @@ def parse_tags(prompt) -> "TaggedStringResult":
 class TaggedStringResult:
     content: Optional[str]
     tag_dict: Optional[Dict[str, str]]
-    mode: str
+    mode: TagPreModes
 
     def __init__(self, content, tag_dict, mode):
         self.content = content
@@ -52,7 +52,7 @@ class TagListVisitor(NodeVisitor):
 
         return TaggedStringResult(content=next(iter(line_opt), None),
                                   tag_dict=next(iter(tag_list_opt), None),
-                                  mode=next(iter(modifier_opt), 'Normal')
+                                  mode=TagPreModes(next(iter(modifier_opt), 'Normal'))
                                   )
 
     @staticmethod

tests/test_tag_interpreter.py

@@ -1,41 +1,39 @@
 import unittest
 
-from ptulsconv.transformations import TagInterpreter
+
+from ptulsconv.docparser.tagged_string_parser_visitor import parse_tags, TagPreModes
 
 
 class TestTagInterpreter(unittest.TestCase):
     def test_line(self):
-        ti = TagInterpreter()
-        s1 = ti.parse_tags("this is a test")
+        s1 = parse_tags("this is a test")
         self.assertEqual(s1.content, "this is a test")
-        self.assertEqual(s1.mode, 'Normal')
+        self.assertEqual(s1.mode, TagPreModes.NORMAL)
         self.assertEqual(len(s1.tag_dict), 0)
 
-        s2 = ti.parse_tags("this! IS! Me! ** Typing! 123 <> |||")
+        s2 = parse_tags("this! IS! Me! ** Typing! 123 <> |||")
         self.assertEqual(s2.content, "this! IS! Me! ** Typing! 123 <> |||")
-        self.assertEqual(s2.mode, 'Normal')
+        self.assertEqual(s2.mode, TagPreModes.NORMAL)
         self.assertEqual(len(s2.tag_dict), 0)
 
     def test_tags(self):
-        ti = TagInterpreter()
-        s1 = ti.parse_tags("{a=100}")
+        s1 = parse_tags("{a=100}")
         self.assertEqual(s1.tag_dict['a'], "100")
 
-        s2 = ti.parse_tags("{b=This is a test} [option] $X=9")
+        s2 = parse_tags("{b=This is a test} [option] $X=9")
         self.assertEqual(s2.tag_dict['b'], 'This is a test')
         self.assertEqual(s2.tag_dict['option'], 'option')
         self.assertEqual(s2.tag_dict['X'], "9")
 
     def test_modes(self):
-        ti = TagInterpreter()
-        s1 = ti.parse_tags("@ Monday Tuesday {a=1}")
-        self.assertEqual(s1.mode, 'Timespan')
+        s1 = parse_tags("@ Monday Tuesday {a=1}")
+        self.assertEqual(s1.mode, TagPreModes.TIMESPAN)
 
-        s2 = ti.parse_tags("Monday Tuesday {a=1}")
-        self.assertEqual(s2.mode, 'Normal')
+        s2 = parse_tags("Monday Tuesday {a=1}")
+        self.assertEqual(s2.mode, TagPreModes.NORMAL)
 
-        s3 = ti.parse_tags("&Monday Tuesday {a=1}")
-        self.assertEqual(s3.mode, 'Append')
+        s3 = parse_tags("&Monday Tuesday {a=1}")
+        self.assertEqual(s3.mode, TagPreModes.APPEND)
 
 
 if __name__ == '__main__':

tests/test_tagcompiler.py

@@ -3,7 +3,6 @@ import unittest
 import ptulsconv.docparser.tag_compiler
 from ptulsconv.docparser import doc_entity
 from fractions import Fraction
-import pprint
 
 
 class TestTagCompiler(unittest.TestCase):