Update __init__.py

Nudging version to 2.2.1
Update pythonpublish.yml
2025-12-31 08:50:48 +00:00 · 2025-05-24 21:58:50 -07:00 · 2025-05-24 21:54:42 -07:00 · 2025-05-18 13:39:06 -07:00 · 2025-05-18 13:37:46 -07:00 · 2025-05-18 13:35:12 -07:00
64 changed files with 1965 additions and 1078 deletions
--- a/.flake8
+++ b/.flake8
@@ -0,0 +1,4 @@
+[flake8]
+per-file-ignores = 
+  ptulsconv/__init__.py: F401
+  ptulsconv/docparser/__init__.py: F401
--- a/.github/workflows/python-package.yml
+++ b/.github/workflows/python-package.yml
@@ -16,7 +16,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        python-version: [3.7, 3.8, 3.9, "3.10"]
+        python-version: [3.8, 3.9, "3.10", "3.11", "3.12"]

    steps:
    - uses: actions/checkout@v2.5.0
@@ -28,7 +28,7 @@ jobs:
      run: |
        python -m pip install --upgrade pip
        python -m pip install flake8 pytest
-        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+        pip install -e .
    - name: Lint with flake8
      run: |
        # stop the build if there are Python syntax errors or undefined names
@@ -37,4 +37,5 @@ jobs:
        flake8 ptulsconv tests --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
    - name: Test with pytest
      run: |
-        PYTHONPATH=. pytest
+        pytest
+        flake8 ptulsconv
--- a/.github/workflows/pythonpublish.yml
+++ b/.github/workflows/pythonpublish.yml
@@ -2,28 +2,38 @@ name: Upload Python Package

 on:
  release:
-    types: [created]
+    types: [published]

+permissions:
+  contents: read
+  id-token: write
+  
 jobs:
  deploy:
    runs-on: ubuntu-latest
+    environment:
+      name: release
    steps:
-    - uses: actions/checkout@v2.5.0
+    - uses: actions/checkout@v3.5.2
    - name: Set up Python
-      uses: actions/setup-python@v4.3.0
+      uses: actions/setup-python@v4.6.0
      with:
        python-version: '3.x'
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
-        pip install setuptools wheel twine
-    - name: Install parsimonious
-      run: |
-        pip install parsimonious
-    - name: Build and publish
-      env:
-        TWINE_USERNAME: __token__
-        TWINE_PASSWORD: ${{ secrets.PYPI_UPLOAD_API_KEY }}
-      run: |
-        python setup.py sdist bdist_wheel
-        twine upload dist/*
+        pip install build
+    - name: Build package
+      run: python -m build
+    - name: pypi-publish
+      uses: pypa/gh-action-pypi-publish@v1.12.4
+    # - name: Report to Mastodon
+    #   uses: cbrgm/mastodon-github-action@v1.0.1
+    #   with:
+    #     message: |
+    #       I just released a new version of ptulsconv, my ADR cue sheet generator!
+    #       #python #protools #pdf #filmmaking 
+    #       ${{ github.server_url }}/${{ github.repository }}
+    #   env:
+    #     MASTODON_URL: ${{ secrets.MASTODON_URL }}
+    #     MASTODON_ACCESS_TOKEN: ${{ secrets.MASTODON_ACCESS_TOKEN }}
--- a/.github/workflows/toot.yml
+++ b/.github/workflows/toot.yml
@@ -0,0 +1,22 @@
+name: Test Toot
+
+on:
+  workflow_dispatch:
+      
+  
+jobs:
+  print-tag:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Report to Mastodon
+      uses: cbrgm/mastodon-github-action@v1.0.1
+      env:
+        MASTODON_URL: ${{ secrets.MASTODON_URL }}
+        MASTODON_ACCESS_TOKEN: ${{ secrets.MASTODON_ACCESS_TOKEN }}
+      with:
+        message: |
+          This is a test toot, automatically posted by a github action.
+          
+          ${{ github.server_url }}/${{ github.repository }}
+          
+          ${{ github.ref }}
--- a/.gitignore
+++ b/.gitignore
@@ -89,6 +89,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+venv_docs/

 # Spyder project settings
 .spyderproject
@@ -105,3 +106,6 @@ venv.bak/
 .DS_Store
 /example/Charade/Session File Backups/
 lcov.info
+
+.vim
+.vscode
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -1,66 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ChangeListManager">
-    <list default="true" id="68bdb183-5bdf-4b42-962e-28e58c31a89d" name="Default Changelist" comment="">
-      <change beforePath="$PROJECT_DIR$/.idea/misc.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/misc.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/.idea/ptulsconv.iml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/ptulsconv.iml" afterDir="false" />
-    </list>
-    <option name="SHOW_DIALOG" value="false" />
-    <option name="HIGHLIGHT_CONFLICTS" value="true" />
-    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
-    <option name="LAST_RESOLUTION" value="IGNORE" />
-  </component>
-  <component name="Git.Settings">
-    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
-  </component>
-  <component name="GitSEFilterConfiguration">
-    <file-type-list>
-      <filtered-out-file-type name="LOCAL_BRANCH" />
-      <filtered-out-file-type name="REMOTE_BRANCH" />
-      <filtered-out-file-type name="TAG" />
-      <filtered-out-file-type name="COMMIT_BY_MESSAGE" />
-    </file-type-list>
-  </component>
-  <component name="ProjectId" id="1yyIGrXKNUCYtI4PSaCWGoLG76R" />
-  <component name="ProjectLevelVcsManager" settingsEditedManually="true" />
-  <component name="ProjectViewState">
-    <option name="hideEmptyMiddlePackages" value="true" />
-    <option name="showLibraryContents" value="true" />
-    <option name="showMembers" value="true" />
-  </component>
-  <component name="PropertiesComponent">
-    <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
-    <property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
-  </component>
-  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="project-level" UseSingleDictionary="true" transferred="true" />
-  <component name="TaskManager">
-    <task active="true" id="Default" summary="Default task">
-      <changelist id="68bdb183-5bdf-4b42-962e-28e58c31a89d" name="Default Changelist" comment="" />
-      <created>1633217312285</created>
-      <option name="number" value="Default" />
-      <option name="presentableId" value="Default" />
-      <updated>1633217312285</updated>
-    </task>
-    <task id="LOCAL-00001" summary="Reorganized README a little">
-      <created>1633221191797</created>
-      <option name="number" value="00001" />
-      <option name="presentableId" value="LOCAL-00001" />
-      <option name="project" value="LOCAL" />
-      <updated>1633221191797</updated>
-    </task>
-    <task id="LOCAL-00002" summary="Manpage 0.8.2 bump">
-      <created>1633221729867</created>
-      <option name="number" value="00002" />
-      <option name="presentableId" value="LOCAL-00002" />
-      <option name="project" value="LOCAL" />
-      <updated>1633221729867</updated>
-    </task>
-    <option name="localTasksCounter" value="3" />
-    <servers />
-  </component>
-  <component name="VcsManagerConfiguration">
-    <MESSAGE value="Reorganized README a little" />
-    <MESSAGE value="Manpage 0.8.2 bump" />
-    <option name="LAST_COMMIT_MESSAGE" value="Manpage 0.8.2 bump" />
-  </component>
-</project>
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -0,0 +1,32 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the version of Python and other tools you might need
+build:
+  os: ubuntu-20.04
+  tools:
+    python: "3.10"
+    # You can also specify other tool versions:
+    # nodejs: "16"
+    # rust: "1.55"
+    # golang: "1.17"
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+   configuration: docs/source/conf.py
+
+#If using Sphinx, optionally build your docs in additional formats such as PDF
+formats:
+   - pdf
+
+#Optionally declare the Python requirements required to build your docs
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - doc
--- a/.vim/coc-settings.json
+++ b/.vim/coc-settings.json
@@ -1,5 +0,0 @@
-{
-  "python.linting.pylintEnabled": true,
-  "python.linting.enabled": true,
-  "python.linting.mypyEnabled": false
-}
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2019 Jamie Hardt
+Copyright (c) 2022 Jamie Hardt

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/README.md
+++ b/README.md
@@ -1,51 +1,20 @@
+[![Documentation Status](https://readthedocs.org/projects/ptulsconv/badge/?version=latest)](https://ptulsconv.readthedocs.io/en/latest/?badge=latest)
 ![](https://img.shields.io/github/license/iluvcapra/ptulsconv.svg)
 ![](https://img.shields.io/pypi/pyversions/ptulsconv.svg) 
 [![](https://img.shields.io/pypi/v/ptulsconv.svg)][pypi]
-![Lint and Test](https://github.com/iluvcapra/ptulsconv/actions/workflows/python-package.yml/badge.svg) 
+![GitHub last commit](https://img.shields.io/github/last-commit/iluvcapra/ptulsconv)
+[![Lint and Test](https://github.com/iluvcapra/ptulsconv/actions/workflows/python-package.yml/badge.svg)](https://github.com/iluvcapra/ptulsconv/actions/workflows/python-package.yml)

 [pypi]: https://pypi.org/project/ptulsconv/


 # ptulsconv

-Read Pro Tools text exports and generate PDF reports, JSON output.
+Parse Pro Tools text exports and generate PDF reports, JSON output.

 ## Quick Start

-For a quick overview of how to cue ADR with `ptulsconv`, check out the [Quickstart](doc/QUICKSTART.md).
- 
-
-## Theory of Operation
-
-[Avid Pro Tools][avp] can be used to make spotting notes for ADR recording
-sessions by creating spotting regions with descriptive text and exporting the
-session as text. This file can then be dropped into Excel or any CSV-reading
-app like Filemaker Pro.
-
-**ptulsconv** accepts a text export from Pro Tools and automatically creates
-PDF and CSV documents for use in ADR spotting, recording, editing and 
-reporting, and supplemental JSON documents can be output for use with other
-workflows.
-
-### Reports Generated by ptulsconv by Default
-
-1. "ADR Report" lists every line in an export with most useful fields, sorted 
-   by time.
-2. "Continuity" lists every scene sorted by time.
-3. "Line Count" lists a count of every line, collated by reel number and by
-   effort/TV/optional line designation.
-4. "CSV" is a folder of files of all lines collated by character and reel
-   as CSV files, for use by studio cueing workflows.
-5. "Director Logs" is a folder of PDFs formatted like the "ADR Report" except
-   collated by character.
-6. "Supervisor Logs" creates a PDF report for every character, with one line
-   per page, optimized for note-taking.
-7. "Talent Scripts" is a minimal PDF layout of just timecode and line prompt,
-   collated by character.
-
-
-[avp]: http://www.avid.com/pro-tools
-
+For a quick overview of how to cue ADR with `ptulsconv`, check out the [Quickstart][quickstart].


 ## Installation
@@ -57,3 +26,5 @@ The easiest way to install on your site is to use `pip`:
 This will install the necessary libraries on your host and gives you 
 command-line access to the tool through an entry-point `ptulsconv`. In a 
 terminal window type `ptulsconv -h` for a list of available options.
+
+[quickstart]: https://ptulsconv.readthedocs.io/en/latest/user/quickstart.html
--- a/doc/HOWTO.md
+++ b/doc/HOWTO.md
@@ -1,92 +0,0 @@
-# How To Use `ptulsconv`
-
-## Theory of Operation
-
-[Avid Pro Tools][avp] exports a tab-delimited text file organized in multiple 
-parts with an uneven syntax that usually can't "drop in" to other tools like 
-Excel or Filemaker. `ptulsconv` will accept a text export from Pro Tools and,
-by default, create a set of PDF reports useful for ADR reporting.
-
-## Tagging 
-
-### Fields in Clip Names
-
-Track names, track comments, and clip names can also contain meta-tags, or 
-"fields," to add additional columns to the CSV output. Thus, if a clip has the 
-name:
-
-`Fireworks explosion {note=Replace for final} $V=1 [FX] [DESIGN]`
-
-The row output for this clip will contain columns for the values:
-
-|...| Clip Name| note | V | FX | DESIGN | ...|
-|---|------------|------|---|----|--------|----|
-|...| Fireworks explosion| Replace for final | 1 | FX | DESIGN | ... |
-
-These fields can be defined in the clip name in three ways:
-* `$NAME=VALUE` creates a field named `NAME` with a one-word value `VALUE`.
-* `{NAME=VALUE}` creates a field named `NAME` with the value `VALUE`. `VALUE` 
-  in this case may contain spaces or any chartacter up to the closing bracket.
-* `[NAME]` creates a field named `NAME` with a value `NAME`. This can be used 
-  to create a boolean-valued field; in the CSV output, clips with the field 
-  will have it, and clips without will have the column with an empty value.
-
-For example, if two clips are named:
-
-`"Squad fifty-one, what is your status?" [FUTZ] {Ch=Dispatcher} [ADR]`
-
-`"We are ten-eight at Rampart Hospital." {Ch=Gage} [ADR]`
-
-The output will contain the range:
-
-|...| PT.Clip.Name| Ch | FUTZ | ADR | ...|
-|---|------------|------|---|----|-----|
-|...| "Squad fifty-one, what is your status?"| Dispatcher | FUTZ | ADR | ... |
-|...| "We are ten-eight at Rampart Hospital."| Gage |  | ADR | ... |
-
-
-### Fields in Track Names and Markers
-
-Fields set in track names, and in track comments, will be applied to *each* 
-clip on that track. If a track comment contains the text `{Dept=Foley}` for 
-example, every clip on that track will have a "Foley" value in a "Dept" column.
-
-Likewise, fields set on the session name will apply to all clips in the session.
-
-Fields set in markers, and in marker comments, will be applied to all clips 
-whose finish is *after* that marker. Fields in markers are applied cumulatively 
-from breakfast to dinner in the session. The latest marker applying to a clip has
-precedence, so if one marker comes after the other, but both define a field, the 
-value in the later marker
-
-An important note here is that, always, fields set on the clip name have the 
-highest precedence. If a field is set in a clip name, the same field set on the 
-track, the value set on the clip will prevail.
-
-### Using `@` to Apply Fields to a Span of Clips
-
-A clip name beginning with "@" will not be included in the CSV output, but its 
-fields will be applied to clips within its time range on lower tracks.
-
-If track 1 has a clip named `@ {Sc=1- The House}`, any clips beginning within 
-that range on lower tracks will have a field `Sc` with that value.
-
-### Using `&` to Combine Clips
-
-A clip name beginning with `&` will have its parsed clip name appended to the 
-preceding cue, and the fields of following cues will be applied, earlier clips 
-having precedence. The clips need not be touching, and the clips will be 
-combined into a single row of the output. The start time of the first clip will
-become the start time of the row, and the finish time of the last clip will 
-become the finish time of the row.
-
-
-## What is `ptulsconv` Useful For?
-
-The main purpose of `ptulsconv` is to read a Pro Tools text export and convert 
-it into PDFs useful for ADR recording.
-
-
-## Is it useful for anything else?
-
-
--- a/doc/QUICKSTART.md
+++ b/doc/QUICKSTART.md
@@ -1,86 +0,0 @@
-# Quick Start for ADR Spotting and Reporting with `ptulsconv`
-
-## Step 1: Use Pro Tools to spot ADR Lines
-
-`ptulsconv` can be used to spot ADR lines similarly to other programs.
-
-1. Create a new Pro Tools session, name this session after your project.
-1. Create new tracks, one for each character. Name each track after a 
-   character.
-1. On each track, create a clip group (or edit in some audio) at the time you 
-   would like an ADR line to appear in the report. Name the clip after the 
-   dialogue you are replacing at that time.
-
-
-## Step 2: Add More Information to Your Spots
-
-Clips, tracks and markers in your session can contain additional information 
-to make your ADR reports more complete and useful. You add this information 
-with *tagging*.
-
- Every ADR clip must have a unique cue number. After the name of each clip,
-  add the letters "$QN=" and then a unique number (any combination of letters 
-  or numbers that don't contain a space). You can type these yourself or add 
-  them with batch-renaming when you're done spotting.
- ADR spots should usually have a reason indicated, so you can remember exactly
-  why you're replacing a particular line. Do this by adding the the text "{R="
-  to your clip names after the prompt and then some short text describing the 
-  reason, and then a closing "}". You can type anything, including spaces.
- If a line is a TV cover line, you can add the text "[TV]" to the end.
-
-So for example, some ADR spot's clip name might look like:
-
-    "Get to the ladder! {R=Noise} $QN=J1001"
-    "Forget your feelings! {R=TV Cover} $QN=J1002 [TV]"
-
-These tags can appear in any order.
-
- You can add the name of an actor to a character's track, so this information
-  will appear on your reports. In the track name, or in the track comments,
-  type "{Actor=xxx}" replacing the xxx with the actor's name.
- Characters need to have a number (perhaps from the cast list) to express how
-  they should be collated. Add "$CN=xxx" with a unique number to each track (or
-  the track's comments.)
- Set the scene for each line with markers. Create a marker at the beginning of 
-  a scene and make it's name "{Sc=xxx}", replacing the xxx with the scene 
-  number and name.
-
-Many tags are available to express different details of each line, like 
-priority, time budget, picture version and reel, notes etc. charater or the 
-project, find them by running `ptulsconv` with the `--show-available-tags`
-option.
-
-
-## Step 3: Export Relevant Tracks from Pro Tools as a Text File
-
-Export the file as a UTF-8 and be sure to include clips and markers. Export 
-using the Timecode time format.
-
-Do not export crossfades.
-
-
-## Step 4: Run `ptulsconv` on the Text Export
-
-In your Terminal, run the following command:
-
-    ptulsconv path/to/your/TEXT_EXPORT.txt
-
-`ptulsconv` will create a folder named "Title_CURRENT_DATE", and within that 
-folder it will create several PDFs and folders:
-
- "TITLE ADR Report" 📄 a PDF tabular report of every ADR line you've spotted.
- "TITLE Continuity" 📄 a PDF listing every scene you have indicated and its 
-  timecode.
- "TITLE Line Count" 📄 a PDF tabular report giving line counts by reel, and the
-  time budget per character and reel (if provided in the tagging).
- "CSV/" a folder containing CSV documents of all spotted ADR, groupd by 
-  character and reel.
- "Director Logs/" 📁 a folder containing PDF tabular reports, like the overall
-  report except groupd by character.
- "Supervisor Logs/" 📁 a folder containing PDF reports, one page per line, 
-  designed for note taking during a session, particularly on an iPad.
- "Talent Scripts/" 📁 a folder containing PDF scripts or sides, with the timecode
-  and prompts for each line, grouped by character but with most other 
-  information suppressed.
-
-
--- a/docs/Makefile
+++ b/docs/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -0,0 +1,77 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+import sys
+import os
+
+sys.path.insert(0, os.path.abspath("../.."))
+print(sys.path)
+
+import ptulsconv
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = 'ptulsconv'
+copyright = '2019-2023 Jamie Hardt. All rights reserved'
+# author = ptulsconv.__author__
+release = ptulsconv.__version__
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.todo',
+    'sphinx.ext.coverage',
+    'sphinx.ext.viewcode',
+    'sphinx.ext.githubpages',
+]
+
+templates_path = ['_templates']
+exclude_patterns = []
+
+
+master_doc = 'index'
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = 'sphinx_rtd_theme'
+html_static_path = ['_static']
+
+
+
+latex_documents = [
+    (master_doc, 'ptulsconv.tex', u'ptulsconv Documentation',
+     u'Jamie Hardt', 'manual'),
+]
+
+
+# -- Options for Epub output -------------------------------------------------
+
+# Bibliographic Dublin Core info.
+epub_title = project
+
+# The unique identifier of the text. This can be a ISBN number
+# or the project homepage.
+#
+# epub_identifier = ''
+
+# A unique identification for the text.
+#
+# epub_uid = ''
+
+# A list of files that should not be packed into the epub file.
+epub_exclude_files = ['search.html']
+
+
+# -- Extension configuration -------------------------------------------------
+
+# -- Options for todo extension ----------------------------------------------
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = True
--- a/docs/source/dev/contributing.rst
+++ b/docs/source/dev/contributing.rst
@@ -0,0 +1,7 @@
+Contributing
+============
+
+Testing
+-------
+
+Before submitting PRs or patches, please make sure your branch passes all of the unit tests by running Pytest.
--- a/docs/source/dev/modules.rst
+++ b/docs/source/dev/modules.rst
@@ -0,0 +1,39 @@
+Auxiliary and Helper Modules
+============================
+
+Commands Module
+---------------
+
+.. automodule:: ptulsconv.commands
+    :members:
+
+
+Broadcast Timecode Module
+-------------------------
+
+.. automodule:: ptulsconv.broadcast_timecode
+    :members:
+
+
+Footage Module
+--------------
+
+.. automodule:: ptulsconv.footage
+    :members:
+
+
+Reporting Module
+----------------
+
+.. automodule:: ptulsconv.reporting
+    :members:
+    :undoc-members:
+
+
+Validations Module
+------------------
+
+.. automodule:: ptulsconv.validations
+    :members:
+    :undoc-members:
+
--- a/docs/source/dev/parsing.rst
+++ b/docs/source/dev/parsing.rst
@@ -0,0 +1,9 @@
+Parsing
+=======
+
+Docparser Classes
+-----------------
+
+.. autoclass:: ptulsconv.docparser.adr_entity.ADRLine
+    :members:
+    :undoc-members:
--- a/docs/source/dev/theory.rst
+++ b/docs/source/dev/theory.rst
@@ -0,0 +1,23 @@
+Theory of Operation
+===================
+
+Execution Flow When Producing "doc" Output
+------------------------------------------
+
+#. The command line argv is read in :py:func:`ptulsconv.__main__.main()`, 
+   which calls :py:func:`ptulsconv.commands.convert()`
+#. :func:`ptulsconv.commands.convert()` reads the input with 
+   :func:`ptuslconv.docparser.doc_parser_visitor()`,
+   which uses the ``parsimonious`` library to parse the input into an abstract
+   syntax tree, which the parser visitor uses to convert into a 
+   :class:`ptulsconv.docparser.doc_entity.SessionDescriptor`, 
+   which structures all of the data in the session output.
+#. The next action based on the output format. In the 
+   case of the "doc" output format, it runs some validations
+   on the input, and calls :func:`ptulsconv.commands.generate_documents()`.
+#. :func:`ptulsconv.commands.generate_documents()` creates the output folder, creates the
+   Continuity report with :func:`ptulsconv.pdf.continuity.output_continuity()` (this document 
+   requires some special-casing), and at the tail calls...
+#. :func:`ptulsconv.commands.create_adr_reports()`, which creates folders for 
+
+(FIXME finish this)
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -0,0 +1,39 @@
+.. ptulsconv documentation master file, created by
+   sphinx-quickstart on Fri Nov 18 10:40:33 2022.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to ptulsconv's documentation!
+=====================================
+
+`ptulsconv` is a tool for converting Pro Tools text exports into PDF
+reports for ADR spotting. It can also be used for converting text
+exports into JSON documents for processing by other applications.
+
+.. toctree::
+   :numbered:
+   :maxdepth: 2
+   :caption: User Documentation
+
+   user/quickstart
+   user/tagging
+   user/for_adr
+   user/cli_reference
+
+.. toctree::
+   :numbered:
+   :maxdepth: 1
+   :caption: Developer Documentation
+
+   dev/contributing
+   dev/theory
+   dev/parsing
+   dev/modules
+ 
+
+Indices and tables
+==================
+
+* :ref:`modindex`
+* :ref:`genindex`
+* :ref:`search`
--- a/docs/source/user/cli_reference.rst
+++ b/docs/source/user/cli_reference.rst
@@ -0,0 +1,74 @@
+Command-Line Reference
+======================
+
+Usage Form
+-----------
+
+Invocations of ptulsconv take the following form:
+
+    ptulsconv [options] IN_FILE
+
+
+Flags
+-----
+
+`-h`, `--help`
+    Show the help message.
+
+`f FMT`, `--format=FMT`
+    Select the output format. By default this is `doc`, which will 
+    generate :ref:`ADR reports<adr-reports>`.
+
+    The :ref:`other available options<alt-output-options>` 
+    are `raw` and `tagged`.
+
+
+Informational Options
+"""""""""""""""""""""
+
+These options display information and exit without processing any
+input documents.
+
+`--show-formats`
+    Display information about available output formats.
+
+`--show-available-tags`
+    Display information about tags that are used by the 
+    report generator.
+
+
+.. _alt-output-options:
+
+Alternate Output Formats
+------------------------
+
+.. _raw-output:
+
+`raw` Output
+""""""""""""
+
+The "raw" output format is a JSON document of the parsed input data.
+
+The document is a top-level dictionary with keys for the main sections of the text export: `header`,
+`files`, `clips`, `plugins`, `tracks` and `markers`, and the values for these are a list of section
+entries, or a dictionary of values, in the case of `header`.
+
+The text values of each record and field in the text export is read and output verbatim, no further 
+processing is done.
+
+.. _tagged-output:
+
+`tagged` Output
+"""""""""""""""
+
+The "tagged" output format is also a JSON document based on the parsed input data, after the additional 
+step of processing all of the :ref:`tags<tags>` in the document.
+
+The document is a top-level array of dictionaries, one for each recognized ADR spotting clip in the 
+session. Each dictionary has a `clip_name`, `track_name` and `session_name` key, a `tags` key that
+contains a dictionary of every parsed tag (after applying tags from all tracks and markers), and a 
+`start` and `end` key. The `start` and `end` key contain the parsed timecode representations of these
+values in rational number form, as a dictionary with `numerator` and `denominator` keys. 
+
+
+
--- a/docs/source/user/for_adr.rst
+++ b/docs/source/user/for_adr.rst
@@ -0,0 +1,129 @@
+.. _adr-reports:
+
+`ptulsconv` For ADR Report Generation
+=====================================
+
+Reports Created by the ADR Report Generator
+-------------------------------------------
+
+(FIXME: write this)
+
+
+Tags Used by the ADR Report Generator
+-------------------------------------
+
+
+Project-Level Tags
+""""""""""""""""""
+
+It usually makes sense to place these either in the session name,
+or on a :ref:`marker <tag-marker>` at the beginning of the session, so it will apply to
+all of the clips in the session.
+
+`Title`
+    The title of the project. This will appear at the top
+    of every report.
+
+.. warning::
+    `ptulsconv` at this time only supports one title per export. If you attempt to
+    use multiple titles in one export it will fail.
+
+`Supv`
+    The supervisor of the project. This appears at the bottom
+    of every report.
+
+`Client`
+    The client of the project. This will often appear under the
+    title on every report.
+
+`Spot`
+    The date or version number of the spotting report.
+
+
+Time Range Tags
+"""""""""""""""
+
+All of these tags can be set to different values on each clip, but
+it often makes sense to use these tags in a :ref:`time range<tag-range>`.
+
+`Sc`
+    The scene description. This appears on the continuity report
+    and is used in the Director's logs.
+
+`Ver`
+    The picture version. This appears beside the spot timecodes
+    on most reports.
+
+`Reel`
+    The reel. This appears beside the spot timecodes
+    on most reports and is used to summarize line totals on the
+    line count report.
+
+
+Line tags
+"""""""""
+
+`P`
+    Priority.
+
+`QN`
+    Cue number. This appears on all reports.
+
+.. warning::
+    `ptulsconv` will verify that all cue numbers in a given title are unique.
+
+    All lines must have a cue number in order to generate reports, if any lines
+    do not have a cue number set, `ptulsconv` will fail.
+
+
+`CN`
+    Character number. This is used to collate character records
+    and will appear on the line count and in character-collated 
+    reports.
+
+`Char`
+    Character name. By default, a clip will set this to the 
+    name of the track it appears on, but the track name can be
+    overridden here.
+
+`Actor` 
+    Actor name.
+
+`Line`
+    The prompt to appear for this ADR line. By default, this
+    will be whatever text appears in a clip name prior to the first
+    tag.
+
+`R` 
+    Reason.
+
+`Mins`
+    Time budget for this line, in minutes. This is used in the
+    line count report to give estimated times for each character. This 
+    can be set for the entire project (with a :ref:`marker <tag-marker>`), or for individual 
+    actors (with a tag in the :ref:`track comments<tag-track>`), or can be set for 
+    individual lines to override these. 
+
+`Shot`
+    Shot. A Date or other description indicating the line has been
+    recorded.
+
+
+Boolean-valued ADR Tag Fields
+"""""""""""""""""""""""""""""
+
+`EFF` 
+    Effort. Lines with this tag are subtotaled in the line count report.
+
+`TV` 
+    TV line. Lines with this tag are subtotaled in the line count report.
+
+`TBW` 
+    To be written.
+
+`ADLIB`
+    Ad-lib.
+
+`OPT` 
+    Optional. Lines with this tag are subtotaled in the line count report.
+
--- a/docs/source/user/quickstart.rst
+++ b/docs/source/user/quickstart.rst
@@ -0,0 +1,87 @@
+Quick Start
+===========
+
+The workflow for creating ADR reports in `ptulsconv` is similar to other ADR 
+spotting programs: spot ADR lines in Pro Tools with clips using a special 
+code to take notes, export the tracks as text and then run the program.
+
+
+Step 1: Use Pro Tools to Spot ADR Lines
+---------------------------------------
+
+`ptulsconv` can be used to spot ADR lines similarly to other programs.
+
+#. Create a new Pro Tools session, name this session after your project.
+#. Create new tracks, one for each character. Name each track after a 
+   character.
+#. On each track, create a clip group (or edit in some audio) at the time you 
+   would like an ADR line to appear in the report. Name the clip after the 
+   dialogue you are replacing at that time.
+
+
+Step 2: Add More Information to Your Spots
+------------------------------------------
+
+Clips, tracks and markers in your session can contain additional information 
+to make your ADR reports more complete and useful. You add this information 
+with :ref:`tagging<tags>`.
+
+* **Every ADR clip must have a unique cue number.** After the name of each
+  clip, add the letters ``$QN=`` and then a unique number (any combination of
+  letters or numbers that don't contain a space). You can type these yourself
+  or add them with batch-renaming when you're done spotting.
+* ADR spots should usually have a reason indicated, so you can remember exactly
+  why you're replacing a particular line. Do this by adding the the text 
+  ``{R=`` to your clip names after the prompt and then some short text 
+  describing the reason, and then a closing ``}``. You can type anything, 
+  including spaces.
+* If, for example, a line is a TV cover line, you can add the text ``[TV]`` to 
+  the end.
+
+So for example, some ADR spot's clip name might look like::
+
+    Get to the ladder! {R=Noise} $QN=J1001
+    "Forget your feelings! {R=TV Cover} $QN=J1002 [TV]
+
+These tags can appear in any order.
+
+* You can add the name of an actor to a character's track, so this information
+  will appear on your reports. In the track name, or in the track comments,
+  type ``{Actor=xxx}`` replacing the xxx with the actor's name.
+* Characters need to have a number (perhaps from the cast list) to express how
+  they should be collated. Add ``$CN=xxx`` with 
+  a unique number to each track (or the track's comments.)
+* Set the scene for each line with markers. Create a marker at the beginning of 
+  a scene and make it's name ``{Sc=xxx}``, replacing the xxx with the scene 
+  number and name.
+
+
+Step 3: Run `ptulsconv`
+------------------------
+
+In Pro Tools, select the tracks that contain your spot clips.
+
+Then, in your Terminal, run the following command::
+
+    ptulsconv
+
+`ptulsconv` will connect to Pro Tools and read all of the clips on the selected
+track. It will then create a folder named "Title_CURRENT_DATE", and within that 
+folder it will create several PDFs and folders:
+
+- "TITLE ADR Report" 📄 a PDF tabular report of every ADR line you've spotted.
+- "TITLE Continuity" 📄 a PDF listing every scene you have indicated and its 
+  timecode.
+- "TITLE Line Count" 📄 a PDF tabular report giving line counts by reel, and the
+  time budget per character and reel (if provided in the tagging).
+- "CSV/" a folder containing CSV documents of all spotted ADR, groupd by 
+  character and reel.
+- "Director Logs/" 📁 a folder containing PDF tabular reports, like the overall
+  report except groupd by character.
+- "Supervisor Logs/" 📁 a folder containing PDF reports, one page per line, 
+  designed for note taking during a session, particularly on an iPad.
+- "Talent Scripts/" 📁 a folder containing PDF scripts or sides, with the timecode
+  and prompts for each line, grouped by character but with most other 
+  information suppressed.
+
+
--- a/docs/source/user/tagging.rst
+++ b/docs/source/user/tagging.rst
@@ -0,0 +1,138 @@
+.. _tags:
+
+Tagging
+=======
+
+Tags are used to add additional data to a clip in an organized way. The
+tagging system in `ptulsconv` is flexible and can be used to add any kind of
+extra data to a clip.
+
+Fields in Clip Names
+--------------------
+
+Track names, track comments, and clip names can also contain meta-tags, or 
+"fields," to add additional columns to the output. Thus, if a clip has the 
+name:::
+
+    Fireworks explosion {note=Replace for final} $V=1 [FX] [DESIGN]
+
+The row output for this clip will contain columns for the values:
+
+
+---------------------+-------------------+---+----+--------+
+| Clip Name           | note              | V | FX | DESIGN |
+=====================+===================+===+====+========+
+| Fireworks explosion | Replace for final | 1 | FX | DESIGN |
+---------------------+-------------------+---+----+--------+
+
+
+These fields can be defined in the clip name in three ways:
+
+  * ``$NAME=VALUE`` creates a field named ``NAME`` with a one-word value
+    ``VALUE``. 
+  * ``{NAME=VALUE}`` creates a field named ``NAME`` with the value ``VALUE``. 
+    ``VALUE`` in this case may contain spaces or any chartacter up  to the 
+    closing bracket.
+  * ``[NAME]`` creates a field named ``NAME`` with a value ``NAME``. This can 
+    be used to create a boolean-valued field; in the output, clips with the 
+    field will have it, and clips without will have the column with an empty
+    value.
+
+For example, if three clips are named:::
+
+    "Squad fifty-one, what is your status?" [FUTZ] {Ch=Dispatcher} [ADR]
+
+    "We are ten-eight at Rampart Hospital." {Ch=Gage} [ADR]
+
+    (1M) FC callouts rescuing trapped survivors. {Ch=Group} $QN=1001 [GROUP]
+
+The output will contain the range:
+
+
+----------------------------------------------+------------+------+-----+------+-------+
+| Clip Name                                    | Ch         | FUTZ | ADR | QN   | GROUP |
+==============================================+============+======+=====+======+=======+
+| "Squad fifty-one, what is your status?"      | Dispatcher | FUTZ | ADR |      |       |
+----------------------------------------------+------------+------+-----+------+-------+
+| "We are ten-eight at Rampart Hospital."      | Gage       |      | ADR |      |       |
+----------------------------------------------+------------+------+-----+------+-------+
+| (1M) FC callouts rescuing trapped survivors. | Group      |      |     | 1001 | GROUP |
+----------------------------------------------+------------+------+-----+------+-------+
+
+
+.. _tag-track:
+.. _tag-marker:
+
+Fields in Track Names and Markers
+---------------------------------
+
+Fields set in track names, and in track comments, will be applied to *each* 
+clip on that track. If a track comment contains the text ``{Dept=Foley}`` for 
+example, every clip on that track will have a "Foley" value in a "Dept" column.
+
+Likewise, fields set on the session name will apply to all clips in the session.
+
+Fields set in markers, and in marker comments, will be applied to all clips 
+whose finish is *after* that marker. Fields in markers are applied cumulatively 
+from breakfast to dinner in the session. The latest marker applying to a clip has
+precedence, so if one marker comes after the other, but both define a field, the 
+value in the later marker.
+
+All markers on all rulers will be scanned for tags. All markers on tracks will 
+be ignored.
+
+An important note here is that, always, fields set on the clip name have the 
+highest precedence. If a field is set in a clip name, the same field set on the 
+track, the value set on the clip will prevail.
+
+
+.. _tag-range:
+
+Apply Fields to a Time Range of Clips
+-------------------------------------
+
+A clip name beginning with ``@`` will not be included in the output, but its 
+fields will be applied to clips within its time range on lower tracks.
+
+If track 1 has a clip named ``@ {Sc=1- The House}``, any clips beginning within 
+that range on lower tracks will have a field ``Sc`` with that value.
+
+
+Combining Clips with Long Names or Many Tags
+--------------------------------------------
+
+A clip name beginning with ``&`` will have its parsed clip name appended to the 
+preceding cue, and the fields of following cues will be applied, earlier clips 
+having precedence. The clips need not be touching, and the clips will be 
+combined into a single row of the output. The start time of the first clip will
+become the start time of the row, and the finish time of the last clip will 
+become the finish time of the row.
+
+
+Setting Document Options
+------------------------
+
+.. note::
+    Document options are not yet implemented.
+
+..
+  A clip beginning with ``!`` sends a command to `ptulsconv`. These commands can 
+  appear anywhere in the document and apply to the entire document. Commands are 
+  a list of words
+
+  The following commands are available:
+
+  page $SIZE=`(letter|legal|a4)`
+      Sets the PDF page size for the output.
+
+  font {NAME=`name`} {PATH=`path`}
+      Sets the primary font for the output.
+
+  sub `replacement text` {FOR=`text_to_replace`} {IN=`tag`}
+      Declares a substitution. Whereever text_to_replace is encountered in the 
+      document it will be replaced with "replacement text".
+
+      If `tag` is set, this substitution will only be applied to the values of 
+      that tag.
+
+
--- a/example/Charade/WaveCache.wfm
+++ b/example/Charade/WaveCache.wfm
--- a/man/ptulsconv.1
+++ b/man/ptulsconv.1
@@ -1,18 +0,0 @@
-.\" Manpage for ptulsconv
-.\" Contact https://github.com/iluvcapra/ptulsconv
-.TH ptulsconv 1 "15 May 2020" "0.8.2" "ptulsconv man page"
-.SH NAME
-.BR "ptulsconv" " \- convert 
-.IR "Avid Pro Tools" " text exports"
-.SH SYNOPSIS
-ptulsconv [OPTIONS] Export.txt
-.SH DESCRIPTION
-Convert a Pro Tools text export into ADR reports.
-.SH OPTIONS
-.IP "-h, --help"
-show a help message and exit.
-.TP
-.RI "--show-available-tags"
-Print a list of tags that are interpreted and exit.
-.SH AUTHOR
-Jamie Hardt (contact at https://github.com/iluvcapra/ptulsconv)
--- a/ptulsconv/init.py
+++ b/ptulsconv/init.py
@@ -1,6 +1,9 @@
-from ptulsconv.docparser.ptuls_grammar import protools_text_export_grammar
+"""
+Parse and convert Pro Tools text exports
+"""

-__version__ = '1.0.4'
-__author__  = 'Jamie Hardt'
+__version__ = '2.2.1'
+__author__ = 'Jamie Hardt'
 __license__ = 'MIT'
-__copyright__ = "%s %s (c) 2022 %s. All rights reserved." % (__name__, __version__, __author__)
+__copyright__ = "%s %s (c) 2025 %s. All rights reserved." \
+        % (__name__, __version__, __author__)
--- a/ptulsconv/main.py
+++ b/ptulsconv/main.py
@@ -2,23 +2,17 @@ from optparse import OptionParser, OptionGroup
 import datetime
 import sys

-from ptulsconv import __name__, __version__, __author__,__copyright__
+from ptulsconv import __name__, __copyright__
 from ptulsconv.commands import convert
-from ptulsconv.reporting import print_status_style, print_banner_style, print_section_header_style, print_fatal_error
-
-
-# TODO: Support Top-level modes
-
-# Modes we want:
-#  - "raw" : Output the parsed text export document with no further processing, as json
-#  - "tagged"? : Output the parsed result of the TagCompiler
-#  - "doc" : Generate a full panoply of PDF reports contextually based on tagging
+from ptulsconv.reporting import print_status_style, \
+    print_banner_style, print_section_header_style, \
+    print_fatal_error


 def dump_field_map(output=sys.stdout):
    from ptulsconv.docparser.tag_mapping import TagMapping
    from ptulsconv.docparser.adr_entity import ADRLine, GenericEvent
-    
+
    TagMapping.print_rules(GenericEvent, output=output)
    TagMapping.print_rules(ADRLine, output=output)

@@ -27,18 +21,18 @@ def dump_formats():
    print_section_header_style("`raw` format:")
    sys.stderr.write("A JSON document of the parsed Pro Tools export.\n")
    print_section_header_style("`tagged` Format:")
-    sys.stderr.write("A JSON document containing one record for each clip, with\n"
-            "all tags parsed and all tagging rules applied. \n")
+    sys.stderr.write(
+        "A JSON document containing one record for each clip, with\n"
+        "all tags parsed and all tagging rules applied. \n")
    print_section_header_style("`doc` format:")
    sys.stderr.write("Creates a directory with folders for different types\n"
-            "of ADR reports.\n\n")
-
+                     "of ADR reports.\n\n")


 def main():
    """Entry point for the command-line invocation"""
    parser = OptionParser()
-    parser.usage = "ptulsconv [options] TEXT_EXPORT.txt"
+    parser.usage = "ptulsconv [options] [TEXT_EXPORT.txt]"

    parser.add_option('-f', '--format',
                      dest='output_format',
@@ -47,44 +41,54 @@ def main():
                      default='doc',
                      help='Set output format, `raw`, `tagged`, `doc`.')

+    parser.add_option('-m', '--movie-opts',
+                      dest='movie_opts',
+                      metavar="MOVIE_OPTS",
+                      help="Set movie options")
+
    warn_options = OptionGroup(title="Warning and Validation Options",
                               parser=parser)

    warn_options.add_option('-W', action='store_false',
                            dest='warnings',
                            default=True,
-                            help='Suppress warnings for common errors (missing code numbers etc.)')
+                            help='Suppress warnings for common '
+                            'errors (missing code numbers etc.)')

    parser.add_option_group(warn_options)

    informational_options = OptionGroup(title="Informational Options",
                                        parser=parser,
-                                        description='Print useful information and exit without processing '
-                                                    'input files.')
+                                        description='Print useful '
+                                        'information '
+                                        'and exit without processing '
+                                        'input files.')

-    informational_options.add_option('--show-formats',
-            dest='show_formats',
-            action='store_true',
-            default=False,
-            help='Display helpful information about the '
-            'available output formats.')
+    informational_options.add_option(
+        '--show-formats',
+        dest='show_formats',
+        action='store_true',
+        default=False,
+        help='Display helpful information about the available '
+        'output formats.')

-    informational_options.add_option('--show-available-tags',
-                                     dest='show_tags',
-                                     action='store_true',
-                                     default=False,
-                                     help='Display tag mappings for the FMP XML '
-                                          'output style and exit.')
+    informational_options.add_option(
+        '--show-available-tags',
+        dest='show_tags',
+        action='store_true',
+        default=False,
+        help='Display tag mappings for the FMP XML output style '
+        'and exit.')

    parser.add_option_group(informational_options)

    print_banner_style(__copyright__)
-    
+
    (options, args) = parser.parse_args(sys.argv)

-
    print_section_header_style("Startup")
-    print_status_style("This run started %s" % (datetime.datetime.now().isoformat()))
+    print_status_style("This run started %s" %
+                       (datetime.datetime.now().isoformat()))

    if options.show_tags:
        dump_field_map()
@@ -93,15 +97,19 @@ def main():
    elif options.show_formats:
        dump_formats()
        sys.exit(0)
-
-    if len(args) < 2:
-        print_fatal_error("Error: No input file")
-        parser.print_help(sys.stderr)
-        sys.exit(22)
-
    try:
        major_mode = options.output_format
-        convert(input_file=args[1], major_mode=major_mode, warnings=options.warnings)
+
+        if len(args) < 2:
+            print_status_style(
+                "No input file provided, will connect to Pro Tools "
+                "with PTSL...")
+            convert(major_mode=major_mode,
+                    warnings=options.warnings)
+        else:
+            convert(input_file=args[1],
+                    major_mode=major_mode,
+                    warnings=options.warnings)

    except FileNotFoundError as e:
        print_fatal_error("Error trying to read input file")
--- a/ptulsconv/broadcast_timecode.py
+++ b/ptulsconv/broadcast_timecode.py
@@ -1,13 +1,23 @@
-from fractions import Fraction
-import re
+"""
+Useful functions for parsing and working with timecode.
+"""
+
 import math
+import re
 from collections import namedtuple
+from fractions import Fraction
 from typing import Optional, SupportsFloat

-class TimecodeFormat(namedtuple("_TimecodeFormat", "frame_duration logical_fps drop_frame")):
+
+class TimecodeFormat(namedtuple("_TimecodeFormat",
+                                "frame_duration logical_fps drop_frame")):
+    """
+    A struct reperesenting a timecode datum.
+    """

    def smpte_to_seconds(self, smpte: str) -> Optional[Fraction]:
-        frame_count = smpte_to_frame_count(smpte, self.logical_fps, drop_frame_hint=self.drop_frame)
+        frame_count = smpte_to_frame_count(
+            smpte, self.logical_fps, drop_frame_hint=self.drop_frame)
        if frame_count is None:
            return None
        else:
@@ -15,29 +25,34 @@ class TimecodeFormat(namedtuple("_TimecodeFormat", "frame_duration logical_fps d

    def seconds_to_smpte(self, seconds: SupportsFloat) -> str:
        frame_count = int(seconds / self.frame_duration)
-        return frame_count_to_smpte(frame_count, self.logical_fps, self.drop_frame)
+        return frame_count_to_smpte(frame_count, self.logical_fps,
+                                    self.drop_frame)


-def smpte_to_frame_count(smpte_rep_string: str, frames_per_logical_second: int, drop_frame_hint=False) -> Optional[int]:
+def smpte_to_frame_count(smpte_rep_string: str, frames_per_logical_second: int,
+                         drop_frame_hint=False) -> Optional[int]:
    """
    Convert a string with a SMPTE timecode representation into a frame count.

    :param smpte_rep_string: The timecode string
-    :param frames_per_logical_second: Num of frames in a logical second. This is asserted to be
-            in one of `[24,25,30,48,50,60]`
-    :param drop_frame_hint: `True` if the timecode rep is drop frame. This is ignored (and implied `True`) if
-            the last separator in the timecode string is a semicolon. This is ignored (and implied `False`) if
-            `frames_per_logical_second` is not 30 or 60.
+    :param frames_per_logical_second: Num of frames in a logical second. This
+        is asserted to be in one of `[24,25,30,48,50,60]`
+    :param drop_frame_hint: `True` if the timecode rep is drop frame. This is
+        ignored (and implied `True`) if the last separator in the timecode
+        string is a semicolon. This is ignored (and implied `False`) if
+        `frames_per_logical_second` is not 30 or 60.
    """
    assert frames_per_logical_second in [24, 25, 30, 48, 50, 60]

-    m = re.search(r'(\d?\d)[:;](\d\d)[:;](\d\d)([:;])(\d\d)(\.\d+)?', smpte_rep_string)
-    
+    m = re.search(
+        r'(\d?\d)[:;](\d\d)[:;](\d\d)([:;])(\d\d)(\.\d+)?', smpte_rep_string)
+
    if m is None:
        return None
-    
+
    hh, mm, ss, sep, ff, frac = m.groups()
-    hh, mm, ss, ff, frac = int(hh), int(mm), int(ss), int(ff), float(frac or 0.0)
+    hh, mm, ss, ff, frac = int(hh), int(
+        mm), int(ss), int(ff), float(frac or 0.0)

    drop_frame = drop_frame_hint
    if sep == ";":
@@ -46,8 +61,8 @@ def smpte_to_frame_count(smpte_rep_string: str, frames_per_logical_second: int,
    if frames_per_logical_second not in [30, 60]:
        drop_frame = False

-    raw_frames = hh * 3600 * frames_per_logical_second + mm * 60 * frames_per_logical_second + \
-                 ss * frames_per_logical_second + ff
+    raw_frames = hh * 3600 * frames_per_logical_second + mm * 60 * \
+        frames_per_logical_second + ss * frames_per_logical_second + ff

    frames = raw_frames
    if drop_frame is True:
@@ -60,7 +75,8 @@ def smpte_to_frame_count(smpte_rep_string: str, frames_per_logical_second: int,
    return frames


-def frame_count_to_smpte(frame_count: int, frames_per_logical_second: int, drop_frame: bool = False,
+def frame_count_to_smpte(frame_count: int, frames_per_logical_second: int,
+                         drop_frame: bool = False,
                         fractional_frame: Optional[float] = None) -> str:
    assert frames_per_logical_second in [24, 25, 30, 48, 50, 60]
    assert fractional_frame is None or fractional_frame < 1.0
@@ -82,7 +98,8 @@ def frame_count_to_smpte(frame_count: int, frames_per_logical_second: int, drop_

    hh = hh % 24
    if fractional_frame is not None and fractional_frame > 0:
-        return "%02i:%02i:%02i%s%02i%s" % (hh, mm, ss, separator, ff, ("%.3f" % fractional_frame)[1:])
+        return "%02i:%02i:%02i%s%02i%s" % (hh, mm, ss, separator, ff,
+                                           ("%.3f" % fractional_frame)[1:])
    else:
        return "%02i:%02i:%02i%s%02i" % (hh, mm, ss, separator, ff)

--- a/ptulsconv/commands.py
+++ b/ptulsconv/commands.py
@@ -1,20 +1,27 @@
+"""
+This module provides the main input document parsing and transform
+implementation.
+"""
 import datetime
 import os

 import sys
 from itertools import chain
 import csv
-from typing import List
+from typing import List, Optional, Iterator
 from fractions import Fraction

-from .docparser.adr_entity import make_entities
-from .reporting import print_section_header_style, print_status_style, print_warning
-from .validations import *
+import ptsl
+
+from .docparser.adr_entity import make_entities, ADRLine
+from .reporting import print_section_header_style, print_status_style, \
+    print_warning
+from .validations import validate_unique_field, validate_non_empty_field, \
+    validate_dependent_value

 from ptulsconv.docparser import parse_document
 from ptulsconv.docparser.tag_compiler import TagCompiler
 from ptulsconv.broadcast_timecode import TimecodeFormat
-from fractions import Fraction

 from ptulsconv.pdf.supervisor_1pg import output_report as output_supervisor_1pg
 from ptulsconv.pdf.line_count import output_report as output_line_count
@@ -25,10 +32,17 @@ from ptulsconv.pdf.continuity import output_report as output_continuity
 from json import JSONEncoder


-class MyEncoder(JSONEncoder):
+class FractionEncoder(JSONEncoder):
+    """
+    A subclass of :class:`JSONEncoder` which encodes :class:`Fraction` objects
+    as a dict.
+    """
    force_denominator: Optional[int]

    def default(self, o):
+        """
+
+        """
        if isinstance(o, Fraction):
            return dict(numerator=o.numerator, denominator=o.denominator)
        else:
@@ -36,6 +50,11 @@ class MyEncoder(JSONEncoder):


 def output_adr_csv(lines: List[ADRLine], time_format: TimecodeFormat):
+    """
+    Writes ADR lines as CSV to the current working directory. Creates
+    directories for each character number and name pair, and within that
+    directory, creates a CSV file for each reel.
+    """
    reels = set([ln.reel for ln in lines])

    for n, name in [(n.character_id, n.character_name) for n in lines]:
@@ -43,12 +62,15 @@ def output_adr_csv(lines: List[ADRLine], time_format: TimecodeFormat):
        os.makedirs(dir_name, exist_ok=True)
        os.chdir(dir_name)
        for reel in reels:
-            these_lines = [ln for ln in lines if ln.character_id == n and ln.reel == reel]
+            these_lines = [ln for ln in lines
+                           if ln.character_id == n and ln.reel == reel]

            if len(these_lines) == 0:
                continue

-            outfile_name = "%s_%s_%s_%s.csv" % (these_lines[0].title, n, these_lines[0].character_name, reel,)
+            outfile_name = "%s_%s_%s_%s.csv" % (these_lines[0].title, n,
+                                                these_lines[0].character_name,
+                                                reel,)

            with open(outfile_name, mode='w', newline='') as outfile:
                writer = csv.writer(outfile, dialect='excel')
@@ -62,25 +84,54 @@ def output_adr_csv(lines: List[ADRLine], time_format: TimecodeFormat):
                for event in these_lines:
                    this_start = event.start or 0
                    this_finish = event.finish or 0
-                    this_row = [event.title, event.character_name, event.cue_number,
-                                event.reel, event.version,
-                                time_format.seconds_to_smpte(this_start), time_format.seconds_to_smpte(this_finish),
+                    this_row = [event.title, event.character_name,
+                                event.cue_number, event.reel, event.version,
+                                time_format.seconds_to_smpte(this_start),
+                                time_format.seconds_to_smpte(this_finish),
                                float(this_start), float(this_finish),
                                event.prompt,
-                                event.reason, event.note, "TV" if event.tv else ""]
+                                event.reason, event.note, "TV"
+                                if event.tv else ""]

                    writer.writerow(this_row)
        os.chdir("..")

-#
-# def output_avid_markers(lines):
-#     reels = set([ln['Reel'] for ln in lines if 'Reel' in ln.keys()])
-#
-#     for reel in reels:
-#         pass
+
+def generate_documents(session_tc_format, scenes, adr_lines: List[ADRLine],
+                       title):
+    """
+    Create PDF output.
+    """
+    print_section_header_style("Creating PDF Reports")
+    report_date = datetime.datetime.now()
+    reports_dir = "%s_%s" % (title, report_date.strftime("%Y-%m-%d_%H%M%S"))
+    os.makedirs(reports_dir, exist_ok=False)
+    os.chdir(reports_dir)
+
+    client = next((x.client for x in adr_lines), "")
+    supervisor = next((x.supervisor for x in adr_lines), "")
+
+    output_continuity(scenes=scenes, tc_display_format=session_tc_format,
+                      title=title, client=client or "",
+                      supervisor=supervisor)
+
+    reels = ['R1', 'R2', 'R3', 'R4', 'R5', 'R6']
+
+    if len(adr_lines) == 0:
+        print_status_style("No ADR lines were found in the input document. "
+                           "ADR reports will not be generated.")
+
+    else:
+        create_adr_reports(adr_lines, tc_display_format=session_tc_format,
+                           reel_list=sorted(reels))


-def create_adr_reports(lines: List[ADRLine], tc_display_format: TimecodeFormat, reel_list):
+def create_adr_reports(lines: List[ADRLine], tc_display_format: TimecodeFormat,
+                       reel_list: List[str]):
+    """
+    Creates a directory heirarchy and a respective set of ADR reports,
+    given a list of lines.
+    """

    print_status_style("Creating ADR Report")
    output_summary(lines, tc_display_format=tc_display_format)
@@ -97,7 +148,8 @@ def create_adr_reports(lines: List[ADRLine], tc_display_format: TimecodeFormat,
    print_status_style("Creating Director's Logs director and reports")
    os.makedirs("Director Logs", exist_ok=True)
    os.chdir("Director Logs")
-    output_summary(lines, tc_display_format=tc_display_format, by_character=True)
+    output_summary(lines, tc_display_format=tc_display_format,
+                   by_character=True)
    os.chdir("..")

    print_status_style("Creating CSV outputs")
@@ -106,36 +158,42 @@ def create_adr_reports(lines: List[ADRLine], tc_display_format: TimecodeFormat,
    output_adr_csv(lines, time_format=tc_display_format)
    os.chdir("..")

-    # print_status_style("Creating Avid Marker XML files")
-    # os.makedirs("Avid Markers", exist_ok=True)
-    # os.chdir("Avid Markers")
-    # output_avid_markers(lines)
-    # os.chdir("..")
-
    print_status_style("Creating Scripts directory and reports")
    os.makedirs("Talent Scripts", exist_ok=True)
    os.chdir("Talent Scripts")
    output_talent_sides(lines, tc_display_format=tc_display_format)


-# def parse_text_export(file):
-#     ast = ptulsconv.protools_text_export_grammar.parse(file.read())
-#     dict_parser = ptulsconv.DictionaryParserVisitor()
-#     parsed = dict_parser.visit(ast)
-#     print_status_style('Session title: %s' % parsed['header']['session_name'])
-#     print_status_style('Session timecode format: %f' % parsed['header']['timecode_format'])
-#     print_status_style('Fount %i tracks' % len(parsed['tracks']))
-#     print_status_style('Found %i markers' % len(parsed['markers']))
-#     return parsed
+def convert(major_mode, input_file=None, output=sys.stdout, warnings=True):
+    """
+    Primary worker function, accepts the input file and decides
+    what to do with it based on the `major_mode`.

+    :param input_file: a path to the input file.
+    :param major_mode: the selected output mode, 'raw', 'tagged' or 'doc'.
+    """
+    session_text = ""
+    if input_file is not None:
+        with open(input_file, "r") as file:
+            session_text = file.read()
+    else:
+        with ptsl.open_engine(
+                company_name="The ptulsconv developers",
+                application_name="ptulsconv") as engine:
+            req = engine.export_session_as_text()
+            req.utf8_encoding()
+            req.include_track_edls()
+            req.include_markers()
+            req.time_type("tc")
+            req.dont_show_crossfades()
+            req.selected_tracks_only()
+            session_text = req.export_string()

-def convert(input_file, major_mode, output=sys.stdout, warnings=True):
-
-    session = parse_document(input_file)
+    session = parse_document(session_text)
    session_tc_format = session.header.timecode_format

    if major_mode == 'raw':
-        output.write(MyEncoder().encode(session))
+        output.write(FractionEncoder().encode(session))

    else:
        compiler = TagCompiler()
@@ -143,57 +201,55 @@ def convert(input_file, major_mode, output=sys.stdout, warnings=True):
        compiled_events = list(compiler.compile_events())

        if major_mode == 'tagged':
-            output.write(MyEncoder().encode(compiled_events))
+            output.write(FractionEncoder().encode(compiled_events))

-        else:
+        elif major_mode == 'doc':
            generic_events, adr_lines = make_entities(compiled_events)

+            scenes = sorted([s for s in compiler.compile_all_time_spans()
+                             if s[0] == 'Sc'],
+                            key=lambda x: x[2])
+
            # TODO: Breakdown by titles
            titles = set([x.title for x in (generic_events + adr_lines)])
-            assert len(titles) == 1, "Multiple titles per export is not supported"
+            if len(titles) != 1:
+                print_warning("Multiple titles per export is not supported, "
+                              "found multiple titles: %s Exiting." % titles)
+                exit(-1)

-            print(titles)
+            title = list(titles)[0]
+
+            print_status_style(
+                "%i generic events found." % len(generic_events)
+            )
+            print_status_style("%i ADR events found." % len(adr_lines))

            if warnings:
-                perform_adr_validations(adr_lines)
+                perform_adr_validations(iter(adr_lines))

-            if major_mode == 'doc':
-                print_section_header_style("Creating PDF Reports")
-                report_date = datetime.datetime.now()
-                reports_dir = "%s_%s" % (list(titles)[0], report_date.strftime("%Y-%m-%d_%H%M%S"))
-                os.makedirs(reports_dir, exist_ok=False)
-                os.chdir(reports_dir)
-
-                scenes = sorted([s for s in compiler.compile_all_time_spans() if s[0] == 'Sc'],
-                                key=lambda x: x[2])
-
-                output_continuity(scenes=scenes, tc_display_format=session_tc_format,
-                                  title=list(titles)[0], client="", supervisor="")
-
-                # reels = sorted([r for r in compiler.compile_all_time_spans() if r[0] == 'Reel'],
-                #                key=lambda x: x[2])
-                reels = ['R1', 'R2', 'R3', 'R4', 'R5', 'R6']
-
-                create_adr_reports(adr_lines,
-                                   tc_display_format=session_tc_format,
-                                   reel_list=sorted(reels))
+            generate_documents(session_tc_format, scenes, adr_lines,
+                               title)


-def perform_adr_validations(lines):
-    for warning in chain(validate_unique_field(lines,
-                                               field='cue_number',
-                                               scope='title'),
-                         validate_non_empty_field(lines,
-                                                  field='cue_number'),
-                         validate_non_empty_field(lines,
-                                                  field='character_id'),
-                         validate_non_empty_field(lines,
-                                                  field='title'),
-                         validate_dependent_value(lines,
-                                                  key_field='character_id',
-                                                  dependent_field='character_name'),
-                         validate_dependent_value(lines,
-                                                  key_field='character_id',
-                                                  dependent_field='actor_name')):
+def perform_adr_validations(lines: Iterator[ADRLine]):
+    """
+    Performs validations on the input.
+    """
+    for warning in chain(
+            validate_unique_field(lines,
+                                  field='cue_number',
+                                  scope='title'),
+            validate_non_empty_field(lines,
+                                     field='cue_number'),
+            validate_non_empty_field(lines,
+                                     field='character_id'),
+            validate_non_empty_field(lines,
+                                     field='title'),
+            validate_dependent_value(lines,
+                                     key_field='character_id',
+                                     dependent_field='character_name'),
+            validate_dependent_value(lines,
+                                     key_field='character_id',
+                                     dependent_field='actor_name')):
+
        print_warning(warning.report_message())
-
--- a/ptulsconv/docparser/init.py
+++ b/ptulsconv/docparser/init.py
@@ -1 +1,5 @@
-from .doc_parser_visitor import parse_document
+"""
+Docparser module
+"""
+
+from .pt_doc_parser import parse_document
--- a/ptulsconv/docparser/adr_entity.py
+++ b/ptulsconv/docparser/adr_entity.py
@@ -1,12 +1,27 @@
+"""
+This module defines classes and methods for converting :class:`Event` objects
+into :class:`ADRLine` objects.
+"""
+
 from ptulsconv.docparser.tag_compiler import Event
-from typing import Optional, List, Tuple 
+from typing import Optional, List, Tuple
 from dataclasses import dataclass
 from fractions import Fraction

 from ptulsconv.docparser.tag_mapping import TagMapping


-def make_entities(from_events: List[Event]) -> Tuple[List['GenericEvent'], List['ADRLine']]:
+def make_entities(from_events: List[Event]) -> Tuple[List['GenericEvent'],
+                                                     List['ADRLine']]:
+    """
+    Accepts a list of Events and converts them into either ADRLine events or
+    GenricEvents by calling :func:`make_entity` on each member.
+
+    :param from_events: A list of `Event` objects.
+
+    :returns: A tuple of two lists, the first containing :class:`GenericEvent`
+        and the second containing :class:`ADRLine`.
+    """
    generic_events = list()
    adr_lines = list()

@@ -21,6 +36,14 @@ def make_entities(from_events: List[Event]) -> Tuple[List['GenericEvent'], List[


 def make_entity(from_event: Event) -> Optional[object]:
+    """
+    Accepts an event and creates either an :class:`ADRLine` or a
+    :class:`GenericEvent`. An event is an "ADRLine" if it has a cue number/"QN"
+    tag field.
+
+    :param from_event:  An :class:`Event`.
+
+    """
    instance = GenericEvent
    tag_map = GenericEvent.tag_mapping
    if 'QN' in from_event.tags.keys():
@@ -45,14 +68,15 @@ class GenericEvent:
    scene: Optional[str] = None
    version: Optional[str] = None
    reel: Optional[str] = None
-    start: Fraction = Fraction(0,1)
-    finish: Fraction = Fraction(0,1)
+    start: Fraction = Fraction(0, 1)
+    finish: Fraction = Fraction(0, 1)
    omitted: bool = False
    note: Optional[str] = None
    requested_by: Optional[str] = None

    tag_mapping = [
-        TagMapping(source='Title', target="title", alt=TagMapping.ContentSource.Session),
+        TagMapping(source='Title', target="title",
+                   alt=TagMapping.ContentSource.Session),
        TagMapping(source="Supv", target="supervisor"),
        TagMapping(source="Client", target="client"),
        TagMapping(source="Sc", target="scene"),
@@ -67,6 +91,7 @@ class GenericEvent:

@dataclass
 class ADRLine(GenericEvent):
+
    priority: Optional[int] = None
    cue_number: Optional[str] = None
    character_id: Optional[str] = None
@@ -88,9 +113,11 @@ class ADRLine(GenericEvent):
        TagMapping(source="P", target="priority"),
        TagMapping(source="QN", target="cue_number"),
        TagMapping(source="CN", target="character_id"),
-        TagMapping(source="Char", target="character_name", alt=TagMapping.ContentSource.Track),
+        TagMapping(source="Char", target="character_name",
+                   alt=TagMapping.ContentSource.Track),
        TagMapping(source="Actor", target="actor_name"),
-        TagMapping(source="Line", target="prompt", alt=TagMapping.ContentSource.Clip),
+        TagMapping(source="Line", target="prompt",
+                   alt=TagMapping.ContentSource.Clip),
        TagMapping(source="R", target="reason"),
        TagMapping(source="Mins", target="time_budget_mins",
                   formatter=(lambda n: float(n))),
@@ -108,31 +135,3 @@ class ADRLine(GenericEvent):
        TagMapping(source="OPT", target="optional",
                   formatter=(lambda x: len(x) > 0))
    ]
-
-    # def __init__(self):
-    #     self.title = None
-    #     self.supervisor = None
-    #     self.client = None
-    #     self.scene = None
-    #     self.version = None
-    #     self.reel = None
-    #     self.start = None
-    #     self.finish = None
-    #     self.priority = None
-    #     self.cue_number = None
-    #     self.character_id = None
-    #     self.character_name = None
-    #     self.actor_name = None
-    #     self.prompt = None
-    #     self.reason = None
-    #     self.requested_by = None
-    #     self.time_budget_mins = None
-    #     self.note = None
-    #     self.spot = None
-    #     self.shot = None
-    #     self.effort = False
-    #     self.tv = False
-    #     self.tbw = False
-    #     self.omitted = False
-    #     self.adlib = False
-    #     self.optional = False
--- a/ptulsconv/docparser/doc_entity.py
+++ b/ptulsconv/docparser/doc_entity.py
@@ -19,21 +19,41 @@ class SessionDescriptor:
        self.tracks = kwargs['tracks']
        self.markers = kwargs['markers']

-    def markers_timed(self) -> Iterator[Tuple['MarkerDescriptor', Fraction]]:
+    def markers_timed(self,
+                      only_ruler_markers: bool = True) -> \
+            Iterator[Tuple['MarkerDescriptor', Fraction]]:
+        """
+        Iterate each marker in the session with its respective time reference.
+        """
        for marker in self.markers:
-            marker_time = Fraction(marker.time_reference, int(self.header.sample_rate))
-            #marker_time = self.header.convert_timecode(marker.location)
+
+            if marker.track_marker and only_ruler_markers:
+                continue
+
+            marker_time = Fraction(marker.time_reference,
+                                   int(self.header.sample_rate))
+            # marker_time = self.header.convert_timecode(marker.location)
            yield marker, marker_time

-    def tracks_clips(self) -> Iterator[Tuple['TrackDescriptor', 'TrackClipDescriptor']]:
+    def tracks_clips(self) -> Iterator[Tuple['TrackDescriptor',
+                                             'TrackClipDescriptor']]:
+        """
+        Iterate each track clip with its respective owning clip.
+        """
        for track in self.tracks:
            for clip in track.clips:
                yield track, clip

-    def track_clips_timed(self) -> Iterator[Tuple["TrackDescriptor", "TrackClipDescriptor",
-                                                  Fraction, Fraction, Fraction]]:
+    def track_clips_timed(self) -> Iterator[Tuple["TrackDescriptor",
+                                                  "TrackClipDescriptor",
+                                                  Fraction, Fraction, Fraction]
+                                            ]:
        """
-        :return: A Generator that yields track, clip, start time, finish time, and timestamp
+        Iterate each track clip with its respective owning clip and timing
+        information.
+
+        :returns: A Generator that yields track, clip, start time, finish time,
+        and timestamp
        """
        for track, clip in self.tracks_clips():
            start_time = self.header.convert_timecode(clip.start_timecode)
@@ -105,10 +125,12 @@ class HeaderDescriptor:
        if self.timecode_fps in frame_rates.keys():
            return frame_rates[self.timecode_fps]
        else:
-            raise ValueError("Unrecognized TC rate (%s)" % self.timecode_format)
+            raise ValueError("Unrecognized TC rate (%s)" %
+                             self.timecode_format)


 class TrackDescriptor:
+    index: int
    name: str
    comments: str
    user_delay_samples: int
@@ -117,6 +139,7 @@ class TrackDescriptor:
    clips: List["TrackClipDescriptor"]

    def __init__(self, **kwargs):
+        self.index = kwargs['index']
        self.name = kwargs['name']
        self.comments = kwargs['comments']
        self.user_delay_samples = kwargs['user_delay_samples']
@@ -165,6 +188,7 @@ class MarkerDescriptor:
    units: str
    name: str
    comments: str
+    track_marker: bool

    def __init__(self, **kwargs):
        self.number = kwargs['number']
@@ -173,3 +197,4 @@ class MarkerDescriptor:
        self.units = kwargs['units']
        self.name = kwargs['name']
        self.comments = kwargs['comments']
+        self.track_marker = kwargs['track_marker']
--- a/ptulsconv/docparser/doc_parser_visitor.py
+++ b/ptulsconv/docparser/doc_parser_visitor.py
@@ -1,172 +0,0 @@
-from parsimonious.nodes import NodeVisitor
-
-from .doc_entity import SessionDescriptor, HeaderDescriptor, TrackDescriptor, FileDescriptor, \
-    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):
-
-    @staticmethod
-    def visit_document(_, visited_children) -> SessionDescriptor:
-        files = next(iter(visited_children[1]), None)
-        clips = next(iter(visited_children[2]), None)
-        plugins = next(iter(visited_children[3]), None)
-        tracks = next(iter(visited_children[4]), None)
-        markers = next(iter(visited_children[5]), None)
-
-        return SessionDescriptor(header=visited_children[0],
-                                 files=files,
-                                 clips=clips,
-                                 plugins=plugins,
-                                 tracks=tracks,
-                                 markers=markers)
-
-    @staticmethod
-    def visit_header(_, visited_children):
-
-        tc_drop = False
-        for _ in visited_children[20]:
-            tc_drop = True
-
-        return HeaderDescriptor(session_name=visited_children[2],
-                                sample_rate=visited_children[6],
-                                bit_depth=visited_children[10],
-                                start_timecode=visited_children[15],
-                                timecode_format=visited_children[19],
-                                timecode_drop_frame=tc_drop,
-                                count_audio_tracks=visited_children[25],
-                                count_clips=visited_children[29],
-                                count_files=visited_children[33])
-
-    @staticmethod
-    def visit_files_section(_, visited_children):
-        return list(map(lambda child: FileDescriptor(filename=child[0], path=child[2]), visited_children[2]))
-
-    @staticmethod
-    def visit_clips_section(_, visited_children):
-        channel = next(iter(visited_children[2][3]), 1)
-
-        return list(map(lambda child: ClipDescriptor(clip_name=child[0], file=child[2], channel=channel),
-                        visited_children[2]))
-
-    @staticmethod
-    def visit_plugin_listing(_, visited_children):
-        return list(map(lambda child: PluginDescriptor(manufacturer=child[0],
-                                                       plugin_name=child[2],
-                                                       version=child[4],
-                                                       format=child[6],
-                                                       stems=child[8],
-                                                       count_instances=child[10]),
-                        visited_children[2]))
-
-    @staticmethod
-    def visit_track_block(_, visited_children):
-        track_header, track_clip_list = visited_children
-        clips = []
-        for clip in track_clip_list:
-            if clip[0] is not None:
-                clips.append(clip[0])
-
-        plugins = []
-        for plugin_opt in track_header[16]:
-            for plugin in plugin_opt[1]:
-                plugins.append(plugin[1])
-
-        return TrackDescriptor(
-            name=track_header[2],
-            comments=track_header[6],
-            user_delay_samples=track_header[10],
-            state=track_header[14],
-            plugins=plugins,
-            clips=clips
-        )
-
-    @staticmethod
-    def visit_frame_rate(node, _):
-        return node.text
-
-    @staticmethod
-    def visit_track_listing(_, visited_children):
-        return visited_children[1]
-
-    @staticmethod
-    def visit_track_clip_entry(_, visited_children):
-        timestamp = None
-        if isinstance(visited_children[14], list):
-            timestamp = visited_children[14][0][0]
-
-        return TrackClipDescriptor(channel=visited_children[0],
-                                   event=visited_children[3],
-                                   clip_name=visited_children[6],
-                                   start_time=visited_children[8],
-                                   finish_time=visited_children[10],
-                                   duration=visited_children[12],
-                                   timestamp=timestamp,
-                                   state=visited_children[15])
-
-    @staticmethod
-    def visit_track_state_list(_, visited_children):
-        states = []
-        for next_state in visited_children:
-            states.append(next_state[0][0].text)
-        return states
-
-    @staticmethod
-    def visit_track_clip_state(node, _):
-        return node.text
-
-    @staticmethod
-    def visit_markers_listing(_, visited_children):
-        markers = []
-
-        for marker in visited_children[2]:
-            markers.append(marker)
-
-        return markers
-
-    @staticmethod
-    def visit_marker_record(_, visited_children):
-        return MarkerDescriptor(number=visited_children[0],
-                                location=visited_children[3],
-                                time_reference=visited_children[5],
-                                units=visited_children[8],
-                                name=visited_children[10],
-                                comments=visited_children[12])
-
-    @staticmethod
-    def visit_formatted_clip_name(_, visited_children):
-        return visited_children[1].text
-
-    @staticmethod
-    def visit_string_value(node, _):
-        return node.text.strip(" ")
-
-    @staticmethod
-    def visit_integer_value(node, _):
-        return int(node.text)
-
-    # def visit_timecode_value(self, node, visited_children):
-    #     return node.text.strip(" ")
-
-    @staticmethod
-    def visit_float_value(node, _):
-        return float(node.text)
-
-    def visit_block_ending(self, node, visited_children):
-        pass
-
-    def generic_visit(self, node, visited_children):
-        """ The generic visit method. """
-        return visited_children or node
--- a/ptulsconv/docparser/generic_entity.py
+++ b/ptulsconv/docparser/generic_entity.py
@@ -1 +1 @@
-from dataclasses import dataclass
+# from dataclasses import dataclass
--- a/ptulsconv/docparser/pt_doc_parser.py
+++ b/ptulsconv/docparser/pt_doc_parser.py
@@ -0,0 +1,307 @@
+from parsimonious.nodes import NodeVisitor
+from parsimonious.grammar import Grammar
+
+from .doc_entity import SessionDescriptor, HeaderDescriptor, TrackDescriptor, \
+    FileDescriptor, TrackClipDescriptor, ClipDescriptor, PluginDescriptor, \
+    MarkerDescriptor
+
+
+protools_text_export_grammar = Grammar(
+    r"""
+    document = header files_section? clips_section? plugin_listing?
+               track_listing? markers_block?
+
+    header   = "SESSION NAME:" fs string_value rs
+               "SAMPLE RATE:" fs float_value rs
+               "BIT DEPTH:" fs integer_value "-bit" rs
+               "SESSION START TIMECODE:" fs string_value rs
+               "TIMECODE FORMAT:" fs frame_rate " Drop"? " Frame" rs
+               "# OF AUDIO TRACKS:" fs integer_value rs
+               "# OF AUDIO CLIPS:" fs integer_value rs
+               "# OF AUDIO FILES:" fs integer_value rs block_ending
+
+    frame_rate           = ("60" / "59.94" / "30" / "29.97" / "25" / "24" /
+                           "23.976")
+    files_section        = files_header files_column_header file_record*
+                           block_ending
+    files_header         = "F I L E S  I N  S E S S I O N" rs
+    files_column_header  = "Filename" isp fs "Location" rs
+    file_record          = string_value fs string_value rs
+
+    clips_section        = clips_header clips_column_header clip_record*
+                           block_ending
+    clips_header         = "O N L I N E  C L I P S  I N  S E S S I O N" rs
+    clips_column_header  = string_value fs string_value rs
+    clip_record          = string_value fs string_value
+                           (fs "[" integer_value "]")? rs
+
+    plugin_listing       = plugin_header plugin_column_header plugin_record*
+                           block_ending
+    plugin_header        = "P L U G - I N S  L I S T I N G" rs
+    plugin_column_header = "MANUFACTURER            " fs
+                           "PLUG-IN NAME            " fs
+                           "VERSION         " fs
+                           "FORMAT          " fs
+                           "STEMS                   " fs
+                           "NUMBER OF INSTANCES" rs
+    plugin_record        = string_value fs string_value fs string_value fs
+                           string_value fs string_value fs string_value rs
+
+    track_listing        = track_listing_header track_block*
+    track_block          = track_list_top ( track_clip_entry / block_ending )*
+
+    track_listing_header = "T R A C K  L I S T I N G" rs
+    track_list_top       = "TRACK NAME:" fs string_value rs
+                           "COMMENTS:" fs string_value rs
+                           "USER DELAY:" fs integer_value " Samples" rs
+                           "STATE: " track_state_list rs
+                           ("PLUG-INS: " ( fs string_value )* rs)?
+                           "CHANNEL " fs "EVENT   " fs
+                           "CLIP NAME                     " fs
+                           "START TIME    " fs "END TIME      " fs
+                           "DURATION      " fs
+                           ("TIMESTAMP         " fs)? "STATE" rs
+
+    track_state_list     = (track_state " ")*
+
+    track_state          = "Solo" / "Muted" / "Inactive" / "Hidden"
+
+    track_clip_entry     = integer_value isp fs
+                           integer_value isp fs
+                           string_value fs
+                           string_value fs string_value fs string_value fs
+                           (string_value fs)?
+                           track_clip_state rs
+
+    track_clip_state     = ("Muted" / "Unmuted")
+
+    markers_block        = markers_block_header
+                           (markers_list / markers_list_simple)
+
+    markers_list_simple  = markers_column_header_simple marker_record_simple*
+
+    markers_list         = markers_column_header marker_record*
+
+    markers_block_header = "M A R K E R S  L I S T I N G" rs
+
+    markers_column_header_simple =
+                          "#   	LOCATION     	TIME REFERENCE    	"
+                          "UNITS    	NAME                             	"
+                          "COMMENTS" rs
+
+    markers_column_header =
+                          "#   	LOCATION     	TIME REFERENCE    	"
+                          "UNITS    	NAME                             	"
+                          "TRACK NAME                       	"
+                          "TRACK TYPE   	COMMENTS" rs
+
+    marker_record_simple   = integer_value isp fs string_value fs
+                            integer_value isp fs string_value fs string_value
+                            fs string_value rs
+
+    marker_record = integer_value isp fs string_value fs integer_value isp fs
+                    string_value fs string_value fs string_value fs
+                    string_value fs string_value rs
+
+    fs = "\t"
+    rs = "\n"
+    block_ending = rs rs
+    string_value   = ~r"[^\t\n]*"
+    integer_value  = ~r"\d+"
+    float_value    = ~r"\d+(\.\d+)?"
+    isp            = ~r"[^\d\t\n]*"
+    """)
+
+
+def parse_document(session_text: str) -> SessionDescriptor:
+    """
+    Parse a Pro Tools text export.
+    :param session_text: Pro Tools session text export
+    :return: the session descriptor
+    """
+    ast = protools_text_export_grammar.parse(session_text)
+    return DocParserVisitor().visit(ast)
+
+
+class DocParserVisitor(NodeVisitor):
+
+    def __init__(self):
+        self.track_index = 0
+
+    # @staticmethod
+    def visit_document(self, _, visited_children) -> SessionDescriptor:
+        self.track_index = 0
+        files = next(iter(visited_children[1]), None)
+        clips = next(iter(visited_children[2]), None)
+        plugins = next(iter(visited_children[3]), None)
+        tracks = next(iter(visited_children[4]), None)
+        markers = next(iter(visited_children[5]), None)
+
+        return SessionDescriptor(header=visited_children[0],
+                                 files=files,
+                                 clips=clips,
+                                 plugins=plugins,
+                                 tracks=tracks,
+                                 markers=markers)
+
+    @staticmethod
+    def visit_header(_, visited_children):
+
+        tc_drop = False
+        for _ in visited_children[20]:
+            tc_drop = True
+
+        return HeaderDescriptor(session_name=visited_children[2],
+                                sample_rate=visited_children[6],
+                                bit_depth=visited_children[10],
+                                start_timecode=visited_children[15],
+                                timecode_format=visited_children[19],
+                                timecode_drop_frame=tc_drop,
+                                count_audio_tracks=visited_children[25],
+                                count_clips=visited_children[29],
+                                count_files=visited_children[33])
+
+    @staticmethod
+    def visit_files_section(_, visited_children):
+        return list(map(
+            lambda child: FileDescriptor(filename=child[0], path=child[2]),
+                    visited_children[2]))
+
+    @staticmethod
+    def visit_clips_section(_, visited_children):
+        channel = next(iter(visited_children[2][3]), 1)
+
+        return list(map(
+            lambda child: ClipDescriptor(clip_name=child[0], file=child[2],
+                                         channel=channel),
+            visited_children[2]))
+
+    @staticmethod
+    def visit_plugin_listing(_, visited_children):
+        return list(map(lambda child:
+                        PluginDescriptor(manufacturer=child[0],
+                                         plugin_name=child[2],
+                                         version=child[4],
+                                         format=child[6],
+                                         stems=child[8],
+                                         count_instances=child[10]),
+                        visited_children[2]))
+
+    # @staticmethod
+    def visit_track_block(self, _, visited_children):
+        track_header, track_clip_list = visited_children
+        clips = []
+        for clip in track_clip_list:
+            if clip[0] is not None:
+                clips.append(clip[0])
+
+        plugins = []
+        for plugin_opt in track_header[16]:
+            for plugin in plugin_opt[1]:
+                plugins.append(plugin[1])
+
+        this_index = self.track_index
+        self.track_index += 1
+
+        return TrackDescriptor(
+            index=this_index,
+            name=track_header[2],
+            comments=track_header[6],
+            user_delay_samples=track_header[10],
+            state=track_header[14],
+            plugins=plugins,
+            clips=clips
+        )
+
+    @staticmethod
+    def visit_frame_rate(node, _):
+        return node.text
+
+    @staticmethod
+    def visit_track_listing(_, visited_children):
+        return visited_children[1]
+
+    @staticmethod
+    def visit_track_clip_entry(_, visited_children):
+        timestamp = None
+        if isinstance(visited_children[14], list):
+            timestamp = visited_children[14][0][0]
+
+        return TrackClipDescriptor(channel=visited_children[0],
+                                   event=visited_children[3],
+                                   clip_name=visited_children[6],
+                                   start_time=visited_children[8],
+                                   finish_time=visited_children[10],
+                                   duration=visited_children[12],
+                                   timestamp=timestamp,
+                                   state=visited_children[15])
+
+    @staticmethod
+    def visit_track_state_list(_, visited_children):
+        states = []
+        for next_state in visited_children:
+            states.append(next_state[0][0].text)
+        return states
+
+    @staticmethod
+    def visit_track_clip_state(node, _):
+        return node.text
+
+    @staticmethod
+    def visit_markers_block(_, visited_children):
+        markers = []
+
+        for marker in visited_children[1][0][1]:
+            markers.append(marker)
+
+        return markers
+
+    @staticmethod
+    def visit_marker_record_simple(_, visited_children):
+
+        return MarkerDescriptor(number=visited_children[0],
+                                location=visited_children[3],
+                                time_reference=visited_children[5],
+                                units=visited_children[8],
+                                name=visited_children[10],
+                                comments=visited_children[12],
+                                track_marker=False)
+
+    @staticmethod
+    def visit_marker_record(_, visited_children):
+        track_type = visited_children[15]
+        is_track_marker = (track_type == "Track")
+
+        return MarkerDescriptor(number=visited_children[0],
+                                location=visited_children[3],
+                                time_reference=visited_children[5],
+                                units=visited_children[8],
+                                name=visited_children[10],
+                                comments=visited_children[16],
+                                track_marker=is_track_marker)
+
+    @staticmethod
+    def visit_formatted_clip_name(_, visited_children):
+        return visited_children[1].text
+
+    @staticmethod
+    def visit_string_value(node, _):
+        return node.text.strip(" ")
+
+    @staticmethod
+    def visit_integer_value(node, _):
+        return int(node.text)
+
+    # def visit_timecode_value(self, node, visited_children):
+    #     return node.text.strip(" ")
+
+    @staticmethod
+    def visit_float_value(node, _):
+        return float(node.text)
+
+    def visit_block_ending(self, node, visited_children):
+        pass
+
+    def generic_visit(self, node, visited_children):
+        """ The generic visit method. """
+        return visited_children or node
--- a/ptulsconv/docparser/ptuls_grammar.py
+++ b/ptulsconv/docparser/ptuls_grammar.py
@@ -1,74 +0,0 @@
-from parsimonious.grammar import Grammar
-
-protools_text_export_grammar = Grammar(
-    r"""
-    document = header files_section? clips_section? plugin_listing? track_listing? markers_listing?
-    header   = "SESSION NAME:" fs string_value rs 
-               "SAMPLE RATE:" fs float_value rs 
-               "BIT DEPTH:" fs integer_value "-bit" rs 
-               "SESSION START TIMECODE:" fs string_value rs 
-               "TIMECODE FORMAT:" fs frame_rate " Drop"? " Frame" rs 
-               "# OF AUDIO TRACKS:" fs integer_value rs 
-               "# OF AUDIO CLIPS:" fs integer_value rs 
-               "# OF AUDIO FILES:" fs integer_value rs block_ending
-    
-    frame_rate           = ("60" / "59.94" / "30" / "29.97" / "25" / "24" / "23.976")
-    files_section        = files_header files_column_header file_record* block_ending
-    files_header         = "F I L E S  I N  S E S S I O N" rs
-    files_column_header  = "Filename" isp fs "Location" rs
-    file_record          = string_value fs string_value rs
-
-    clips_section        = clips_header clips_column_header clip_record* block_ending
-    clips_header         = "O N L I N E  C L I P S  I N  S E S S I O N" rs
-    clips_column_header  = string_value fs string_value rs
-    clip_record          = string_value fs string_value (fs "[" integer_value "]")? rs
-
-    plugin_listing       = plugin_header plugin_column_header plugin_record* block_ending
-    plugin_header        = "P L U G - I N S  L I S T I N G" rs
-    plugin_column_header = "MANUFACTURER            " fs "PLUG-IN NAME            " fs 
-                           "VERSION         " fs "FORMAT          " fs "STEMS                   " fs 
-                           "NUMBER OF INSTANCES" rs
-    plugin_record        = string_value fs string_value fs string_value fs 
-                           string_value fs string_value fs string_value rs
-
-    track_listing        = track_listing_header track_block*
-    track_block          = track_list_top ( track_clip_entry / block_ending )*
-    
-    track_listing_header = "T R A C K  L I S T I N G" rs
-    track_list_top       = "TRACK NAME:" fs string_value rs
-                           "COMMENTS:" fs string_value rs
-                           "USER DELAY:" fs integer_value " Samples" rs
-                           "STATE: " track_state_list rs
-                           ("PLUG-INS: " ( fs string_value )* rs)?
-                           "CHANNEL " fs "EVENT   " fs "CLIP NAME                     " fs 
-                           "START TIME    " fs "END TIME      " fs "DURATION      " fs 
-                           ("TIMESTAMP         " fs)? "STATE" rs
-    
-    track_state_list     = (track_state " ")*
-    
-    track_state          = "Solo" / "Muted" / "Inactive" / "Hidden"
-    
-    track_clip_entry     = integer_value isp fs 
-                           integer_value isp fs 
-                           string_value fs 
-                           string_value fs string_value fs string_value fs (string_value fs)? 
-                           track_clip_state rs
-                           
-    track_clip_state     = ("Muted" / "Unmuted")
-
-    markers_listing        = markers_listing_header markers_column_header marker_record*
-    markers_listing_header = "M A R K E R S  L I S T I N G" rs
-    markers_column_header  = "#   " fs "LOCATION     " fs "TIME REFERENCE    " fs 
-                             "UNITS    " fs "NAME                             " fs "COMMENTS" rs
-
-    marker_record = integer_value isp fs string_value fs integer_value isp fs 
-                    string_value fs string_value fs string_value rs             
-
-    fs = "\t"
-    rs = "\n"
-    block_ending = rs rs
-    string_value   = ~r"[^\t\n]*"
-    integer_value  = ~r"\d+"
-    float_value    = ~r"\d+(\.\d+)?"
-    isp            = ~r"[^\d\t\n]*"    
-    """)
--- a/ptulsconv/docparser/tag_compiler.py
+++ b/ptulsconv/docparser/tag_compiler.py
@@ -19,18 +19,30 @@ class Event:


 class TagCompiler:
+    """
+    Uses a `SessionDescriptor` as a data source to produce `Intermediate`
+    items.
+    """

-    Intermediate = namedtuple('Intermediate', 'track_content track_tags track_comment_tags '
-                                              'clip_content clip_tags clip_tag_mode start finish')
+    Intermediate = namedtuple('Intermediate',
+                              'track_content track_tags track_comment_tags '
+                              'clip_content clip_tags clip_tag_mode start '
+                              'finish')

    session: doc_entity.SessionDescriptor

-    def compile_all_time_spans(self) -> List[Tuple[str, str, Fraction, Fraction]]:
+    def compile_all_time_spans(self) -> List[Tuple[str, str, Fraction,
+                                                   Fraction]]:
+        """
+        :returns: A `List` of (key: str, value: str, start: Fraction,
+            finish: Fraction)
+        """
        ret_list = list()
        for element in self.parse_data():
            if element.clip_tag_mode == TagPreModes.TIMESPAN:
                for k in element.clip_tags.keys():
-                    ret_list.append((k, element.clip_tags[k], element.start, element.finish))
+                    ret_list.append((k, element.clip_tags[k], element.start,
+                                     element.finish))

        return ret_list

@@ -61,22 +73,36 @@ class TagCompiler:

    def compile_events(self) -> Iterator[Event]:
        step0 = self.parse_data()
-        step1 = self.apply_appends(step0)
-        step2 = self.collect_time_spans(step1)
-        step3 = self.apply_tags(step2)
-        for datum in step3:
-            yield Event(clip_name=datum[0], track_name=datum[1], session_name=datum[2],
-                        tags=datum[3], start=datum[4], finish=datum[5])
+        step1 = self.filter_out_directives(step0)
+        step2 = self.apply_appends(step1)
+        step3 = self.collect_time_spans(step2)
+        step4 = self.apply_tags(step3)
+        for datum in step4:
+            yield Event(clip_name=datum[0], track_name=datum[1],
+                        session_name=datum[2], tags=datum[3], start=datum[4],
+                        finish=datum[5])

    def _marker_tags(self, at):
        retval = dict()
-        applicable = [(m, t) for (m, t) in self.session.markers_timed() if t <= at]
+
+        applicable = [(m, t) for (m, t) in
+                      self.session.markers_timed() if t <= at]
+
        for marker, _ in sorted(applicable, key=lambda x: x[1]):
            retval.update(parse_tags(marker.comments or "").tag_dict)
            retval.update(parse_tags(marker.name or "").tag_dict)

        return retval

+    def filter_out_directives(self,
+                              clips: Iterator[Intermediate]) \
+            -> Iterator[Intermediate]:
+        for clip in clips:
+            if clip.clip_tag_mode == 'Directive':
+                continue
+            else:
+                yield clip
+
    @staticmethod
    def _coalesce_tags(clip_tags: dict, track_tags: dict,
                       track_comment_tags: dict,
@@ -101,29 +127,33 @@ class TagCompiler:
            track_comments_parsed = parse_tags(track.comments)
            clip_parsed = parse_tags(clip.clip_name)

-            yield TagCompiler.Intermediate(track_content=track_parsed.content,
-                                           track_tags=track_parsed.tag_dict,
-                                           track_comment_tags=track_comments_parsed.tag_dict,
-                                           clip_content=clip_parsed.content,
-                                           clip_tags=clip_parsed.tag_dict,
-                                           clip_tag_mode=clip_parsed.mode,
-                                           start=start, finish=finish)
+            yield TagCompiler.Intermediate(
+                track_content=track_parsed.content,
+                track_tags=track_parsed.tag_dict,
+                track_comment_tags=track_comments_parsed.tag_dict,
+                clip_content=clip_parsed.content,
+                clip_tags=clip_parsed.tag_dict,
+                clip_tag_mode=clip_parsed.mode,
+                start=start, finish=finish)

    @staticmethod
-    def apply_appends(parsed: Iterator[Intermediate]) -> Iterator[Intermediate]:
+    def apply_appends(parsed: Iterator[Intermediate]) -> \
+            Iterator[Intermediate]:

        def should_append(a, b):
-            return b.clip_tag_mode == TagPreModes.APPEND and b.start >= a.finish
+            return b.clip_tag_mode == TagPreModes.APPEND and \
+                b.start >= a.finish

        def do_append(a, b):
            merged_tags = dict(a.clip_tags)
            merged_tags.update(b.clip_tags)
-            return TagCompiler.Intermediate(track_content=a.track_content,
-                                            track_tags=a.track_tags,
-                                            track_comment_tags=a.track_comment_tags,
-                                            clip_content=a.clip_content + ' ' + b.clip_content,
-                                            clip_tags=merged_tags, clip_tag_mode=a.clip_tag_mode,
-                                            start=a.start, finish=b.finish)
+            return TagCompiler.Intermediate(
+                track_content=a.track_content,
+                track_tags=a.track_tags,
+                track_comment_tags=a.track_comment_tags,
+                clip_content=a.clip_content + ' ' + b.clip_content,
+                clip_tags=merged_tags, clip_tag_mode=a.clip_tag_mode,
+                start=a.start, finish=b.finish)

        yield from apply_appends(parsed, should_append, do_append)

@@ -142,12 +172,14 @@ class TagCompiler:
    @staticmethod
    def _time_span_tags(at_time: Fraction, applicable_spans) -> dict:
        retval = dict()
-        for tags in reversed([a[0] for a in applicable_spans if a[1] <= at_time <= a[2]]):
+        for tags in reversed([a[0] for a in applicable_spans
+                              if a[1] <= at_time <= a[2]]):
            retval.update(tags)

        return retval

-    def apply_tags(self, parsed_with_time_spans) -> Iterator[Tuple[str, str, str, dict, Fraction, Fraction]]:
+    def apply_tags(self, parsed_with_time_spans) ->\
+            Iterator[Tuple[str, str, str, dict, Fraction, Fraction]]:

        session_parsed = parse_tags(self.session.header.session_name)

@@ -155,14 +187,16 @@ class TagCompiler:
            event: 'TagCompiler.Intermediate'
            marker_tags = self._marker_tags(event.start)
            time_span_tags = self._time_span_tags(event.start, time_spans)
-            tags = self._coalesce_tags(clip_tags=event.clip_tags,
-                                       track_tags=event.track_tags,
-                                       track_comment_tags=event.track_comment_tags,
-                                       timespan_tags=time_span_tags,
-                                       marker_tags=marker_tags,
-                                       session_tags=session_parsed.tag_dict)
+            tags = self._coalesce_tags(
+                    clip_tags=event.clip_tags,
+                    track_tags=event.track_tags,
+                    track_comment_tags=event.track_comment_tags,
+                    timespan_tags=time_span_tags,
+                    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)


 def apply_appends(source: Iterator,
--- a/ptulsconv/docparser/tag_mapping.py
+++ b/ptulsconv/docparser/tag_mapping.py
@@ -48,7 +48,8 @@ class TagMapping:
        for rule in rules:
            if rule.target in done:
                continue
-            if rule.apply(tags, clip_content, track_content, session_content, to):
+            if rule.apply(tags, clip_content, track_content, session_content,
+                          to):
                done.update(rule.target)

    def __init__(self, source: str,
--- a/ptulsconv/docparser/tagged_string_parser_visitor.py
+++ b/ptulsconv/docparser/tagged_string_parser_visitor.py
@@ -1,5 +1,5 @@
 from parsimonious import NodeVisitor, Grammar
-from typing import Dict, Optional
+from typing import Dict
 from enum import Enum


@@ -7,6 +7,7 @@ class TagPreModes(Enum):
    NORMAL = 'Normal'
    APPEND = 'Append'
    TIMESPAN = 'Timespan'
+    DIRECTIVE = 'Directive'


 tag_grammar = Grammar(
@@ -23,7 +24,7 @@ tag_grammar = Grammar(
    tag_junk       = word word_sep?
    word           = ~r"[^ \[\{\$][^ ]*"
    word_sep       = ~r" +"
-    modifier       = ("@" / "&") word_sep?
+    modifier       = ("@" / "&" /"!") word_sep?
    """
 )

@@ -51,8 +52,9 @@ class TagListVisitor(NodeVisitor):
        modifier_opt, line_opt, _, tag_list_opt = visited_children

        return TaggedStringResult(content=next(iter(line_opt), None),
-                                  tag_dict=next(iter(tag_list_opt), None),
-                                  mode=TagPreModes(next(iter(modifier_opt), 'Normal'))
+                                  tag_dict=next(iter(tag_list_opt), dict()),
+                                  mode=TagPreModes(
+                                      next(iter(modifier_opt), 'Normal'))
                                  )

    @staticmethod
@@ -65,6 +67,8 @@ class TagListVisitor(NodeVisitor):
            return TagPreModes.TIMESPAN
        elif node.text.startswith('&'):
            return TagPreModes.APPEND
+        elif node.text.startswith('!'):
+            return TagPreModes.DIRECTIVE
        else:
            return TagPreModes.NORMAL

--- a/ptulsconv/footage.py
+++ b/ptulsconv/footage.py
@@ -1,8 +1,20 @@
+"""
+Methods for converting string reprentations of film footage.
+"""
 from fractions import Fraction
 import re
 from typing import Optional

+
 def footage_to_seconds(footage: str) -> Optional[Fraction]:
+    """
+    Converts a string representation of a footage (35mm, 24fps)
+    into a :class:`Fraction`, this fraction being a some number of
+    seconds.
+
+    :param footage: A string reprenentation of a footage of the form
+        resembling "90+01".
+    """
    m = re.match(r'(\d+)\+(\d+)(\.\d+)?', footage)
    if m is None:
        return None
--- a/ptulsconv/movie_export.py
+++ b/ptulsconv/movie_export.py
@@ -1,12 +1,14 @@
-#import ffmpeg # ffmpeg-python
+# import ffmpeg # ffmpeg-python

 # TODO: Implement movie export

 # def create_movie(event):
 #     start = event['Movie.Start_Offset_Seconds']
-#     duration = event['PT.Clip.Finish_Seconds'] - event['PT.Clip.Start_Seconds']
+#     duration = event['PT.Clip.Finish_Seconds'] -
+# event['PT.Clip.Start_Seconds']
 #     input_movie = event['Movie.Filename']
-#     print("Will make movie starting at {}, dur {} from movie {}".format(start, duration, input_movie))
+#     print("Will make movie starting at {}, dur {} from movie {}"
+#          .format(start, duration, input_movie))
 #
 #
 # def export_movies(events):
--- a/ptulsconv/pdf/init.py
+++ b/ptulsconv/pdf/init.py
@@ -17,6 +17,8 @@ from typing import List

 # This is from https://code.activestate.com/recipes/576832/ for
 # generating page count messages
+
+
 class ReportCanvas(canvas.Canvas):
    def __init__(self, *args, **kwargs):
        canvas.Canvas.__init__(self, *args, **kwargs)
@@ -38,10 +40,12 @@ class ReportCanvas(canvas.Canvas):

    def draw_page_number(self, page_count):
        self.saveState()
-        self.setFont('Helvetica', 10) #FIXME make this customizable
-        self.drawString(0.5 * inch, 0.5 * inch, "Page %d of %d" % (self._pageNumber, page_count))
+        self.setFont('Helvetica', 10)  # FIXME make this customizable
+        self.drawString(0.5 * inch, 0.5 * inch,
+                        "Page %d of %d" % (self._pageNumber, page_count))
        right_edge = self._pagesize[0] - 0.5 * inch
-        self.drawRightString(right_edge, 0.5 * inch, self._report_date.strftime("%m/%d/%Y %H:%M"))
+        self.drawRightString(right_edge, 0.5 * inch,
+                             self._report_date.strftime("%m/%d/%Y %H:%M"))

        top_line = self.beginPath()
        top_line.moveTo(0.5 * inch, 0.75 * inch)
@@ -74,16 +78,18 @@ def make_doc_template(page_size, filename, document_title,
    footer_box, page_box = page_box.split_y(0.25 * inch, direction='u')
    header_box, page_box = page_box.split_y(0.75 * inch, direction='d')
    title_box, report_box = header_box.split_x(3.5 * inch, direction='r')
-    
-    on_page_lambda = (lambda c, _: 
-        draw_header_footer(c, report_box, title_box, 
-        footer_box,title=title, 
-        supervisor=supervisor,     
-        document_subheader=document_subheader, 
-        client=client, doc_title=document_header))
-    
-    frames = [Frame(page_box.min_x, page_box.min_y, page_box.width, page_box.height)]
-    
+
+    on_page_lambda = (lambda c, _:
+                      draw_header_footer(c, report_box, title_box,
+                                         footer_box, title=title,
+                                         supervisor=supervisor,
+                                         document_subheader=document_subheader,
+                                         client=client,
+                                         doc_title=document_header))
+
+    frames = [Frame(page_box.min_x, page_box.min_y,
+                    page_box.width, page_box.height)]
+
    page_template = PageTemplate(id="Main",
                                 frames=frames,
                                 onPage=on_page_lambda)
@@ -119,12 +125,17 @@ def time_format(mins, zero_str="-"):
        return "%i:%02i" % (hh, mm)


-def draw_header_footer(a_canvas: ReportCanvas, left_box, right_box, footer_box, title: str, supervisor: str,
-                       document_subheader: str, client: str, doc_title="", font_name='Helvetica'):
+def draw_header_footer(a_canvas: ReportCanvas, left_box, right_box,
+                       footer_box, title: str, supervisor: str,
+                       document_subheader: str, client: str, doc_title="",
+                       font_name='Helvetica'):

-    (_supervisor_box, client_box,), title_box = right_box.divide_y([16., 16., ])
-    title_box.draw_text_cell(a_canvas, title, font_name, 18, inset_y=2., inset_x=5.)
-    client_box.draw_text_cell(a_canvas, client, font_name, 11, inset_y=2., inset_x=5.)
+    (_supervisor_box, client_box,), title_box = \
+        right_box.divide_y([16., 16., ])
+    title_box.draw_text_cell(a_canvas, title, font_name, 18,
+                             inset_y=2., inset_x=5.)
+    client_box.draw_text_cell(a_canvas, client, font_name, 11,
+                              inset_y=2., inset_x=5.)

    a_canvas.saveState()
    a_canvas.setLineWidth(0.5)
@@ -139,16 +150,20 @@ def draw_header_footer(a_canvas: ReportCanvas, left_box, right_box, footer_box,
    a_canvas.drawPath(tline2)
    a_canvas.restoreState()

-    (doc_title_cell, spotting_version_cell,), _ = left_box.divide_y([18., 14], direction='d')
+    (doc_title_cell, spotting_version_cell,), _ = \
+        left_box.divide_y([18., 14], direction='d')

-    doc_title_cell.draw_text_cell(a_canvas, doc_title, font_name, 14., inset_y=2.)
+    doc_title_cell.draw_text_cell(a_canvas, doc_title, font_name, 14.,
+                                  inset_y=2.)

    if document_subheader is not None:
-        spotting_version_cell.draw_text_cell(a_canvas, document_subheader, font_name, 12., inset_y=2.)
+        spotting_version_cell.draw_text_cell(a_canvas, document_subheader,
+                                             font_name, 12., inset_y=2.)

    if supervisor is not None:
        a_canvas.setFont(font_name, 11.)
-        a_canvas.drawCentredString(footer_box.min_x + footer_box.width / 2., footer_box.min_y, supervisor)
+        a_canvas.drawCentredString(footer_box.min_x + footer_box.width / 2.,
+                                   footer_box.min_y, supervisor)


 class GRect:
@@ -201,10 +216,12 @@ class GRect:
        else:
            if direction == 'l':
                return (GRect(self.min_x, self.min_y, at, self.height),
-                        GRect(self.min_x + at, self.y, self.width - at, self.height))
+                        GRect(self.min_x + at, self.y,
+                              self.width - at, self.height))
            else:
                return (GRect(self.max_x - at, self.y, at, self.height),
-                        GRect(self.min_x, self.y, self.width - at, self.height))
+                        GRect(self.min_x, self.y,
+                              self.width - at, self.height))

    def split_y(self, at, direction='u'):
        if at >= self.height:
@@ -214,19 +231,23 @@ class GRect:
        else:
            if direction == 'u':
                return (GRect(self.x, self.y, self.width, at),
-                        GRect(self.x, self.y + at, self.width, self.height - at))
+                        GRect(self.x, self.y + at,
+                              self.width, self.height - at))
            else:
                return (GRect(self.x, self.max_y - at, self.width, at),
-                        GRect(self.x, self.y, self.width, self.height - at))
+                        GRect(self.x, self.y,
+                              self.width, self.height - at))

    def inset_xy(self, dx, dy):
-        return GRect(self.x + dx, self.y + dy, self.width - dx * 2, self.height - dy * 2)
+        return GRect(self.x + dx, self.y + dy,
+                     self.width - dx * 2, self.height - dy * 2)

    def inset(self, d):
        return self.inset_xy(d, d)

    def __repr__(self):
-        return "<GRect x=%f y=%f width=%f height=%f>" % (self.x, self.y, self.width, self.height)
+        return "<GRect x=%f y=%f width=%f height=%f>" % \
+            (self.x, self.y, self.width, self.height)

    def divide_x(self, x_list, direction='l'):
        ret_list = list()
@@ -259,13 +280,17 @@ class GRect:

        def draw_border_impl(en):
            if en == 'min_x':
-                coordinates = ((self.min_x, self.min_y), (self.min_x, self.max_y))
+                coordinates = ((self.min_x, self.min_y),
+                               (self.min_x, self.max_y))
            elif en == 'max_x':
-                coordinates = ((self.max_x, self.min_y), (self.max_x, self.max_y))
+                coordinates = ((self.max_x, self.min_y),
+                               (self.max_x, self.max_y))
            elif en == 'min_y':
-                coordinates = ((self.min_x, self.min_y), (self.max_x, self.min_y))
+                coordinates = ((self.min_x, self.min_y),
+                               (self.max_x, self.min_y))
            elif en == 'max_y':
-                coordinates = ((self.min_x, self.max_y), (self.max_x, self.max_y))
+                coordinates = ((self.min_x, self.max_y),
+                               (self.max_x, self.max_y))
            else:
                return

--- a/ptulsconv/pdf/continuity.py
+++ b/ptulsconv/pdf/continuity.py
@@ -4,7 +4,7 @@ from typing import Tuple, List
 from reportlab.lib.pagesizes import portrait, letter
 from reportlab.lib.styles import getSampleStyleSheet
 from reportlab.lib.units import inch
-from reportlab.platypus import Paragraph, Table, Spacer
+from reportlab.platypus import Paragraph, Table

 from ptulsconv.broadcast_timecode import TimecodeFormat
 from ptulsconv.pdf import make_doc_template
@@ -12,14 +12,15 @@ from ptulsconv.pdf import make_doc_template

 # TODO: A Continuity

-def table_for_scene(scene, tc_format, font_name = 'Helvetica'):
+def table_for_scene(scene, tc_format, font_name='Helvetica'):
    scene_style = getSampleStyleSheet()['Normal']
    scene_style.fontName = font_name
    scene_style.leftIndent = 0.
    scene_style.leftPadding = 0.
    scene_style.spaceAfter = 18.

-    tc_data = "<em>%s</em><br />%s" % (tc_format.seconds_to_smpte(scene[2]), tc_format.seconds_to_smpte(scene[3]))
+    tc_data = "<em>%s</em><br />%s" % (tc_format.seconds_to_smpte(scene[2]),
+                                       tc_format.seconds_to_smpte(scene[3]))

    row = [
        Paragraph(tc_data, scene_style),
@@ -36,11 +37,11 @@ def table_for_scene(scene, tc_format, font_name = 'Helvetica'):

 def output_report(scenes: List[Tuple[str, str, Fraction, Fraction]],
                  tc_display_format: TimecodeFormat,
-                  title: str, client: str, supervisor):
+                  title: str, client: str, supervisor, paper_size=letter):
    filename = "%s Continuity.pdf" % title
    document_header = "Continuity"

-    doc = make_doc_template(page_size=portrait(letter),
+    doc = make_doc_template(page_size=portrait(paper_size),
                            filename=filename,
                            document_title="Continuity",
                            title=title,
--- a/ptulsconv/pdf/line_count.py
+++ b/ptulsconv/pdf/line_count.py
@@ -1,7 +1,7 @@
 from typing import List, Optional

-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
+# from reportlab.pdfbase import pdfmetrics
+# from reportlab.pdfbase.ttfonts import TTFont

 from reportlab.lib.units import inch
 from reportlab.lib.pagesizes import letter, portrait
@@ -14,9 +14,12 @@ from .__init__ import time_format, make_doc_template
 from ..docparser.adr_entity import ADRLine


-def build_columns(lines: List[ADRLine], reel_list: Optional[List[str]], show_priorities=False, include_omitted=False):
+def build_columns(lines: List[ADRLine], reel_list: Optional[List[str]],
+                  show_priorities=False, include_omitted=False):
    columns = list()
-    reel_numbers = reel_list or sorted(set([x.reel for x in lines if x.reel is not None]))
+    reel_numbers = reel_list or sorted(
+        set([x.reel for x in lines if x.reel is not None])
+    )

    num_column_width = 15. / 32. * inch

@@ -33,7 +36,10 @@ def build_columns(lines: List[ADRLine], reel_list: Optional[List[str]], show_pri
        'heading': 'Role',
        'value_getter': lambda recs: recs[0].character_name,
        'value_getter2': lambda recs: recs[0].actor_name or "",
-        'style_getter': lambda col_index: [('LINEAFTER', (col_index, 0), (col_index, -1), 1.0, colors.black)],
+        'style_getter': lambda col_index: [('LINEAFTER',
+                                            (col_index, 0),
+                                            (col_index, -1),
+                                            1.0, colors.black)],
        'width': 1.75 * inch,
        'summarize': False
    })
@@ -41,30 +47,48 @@ def build_columns(lines: List[ADRLine], reel_list: Optional[List[str]], show_pri
    columns.append({
        'heading': 'TV',
        'value_getter': lambda recs: len([r for r in recs if r.tv]),
-        'value_getter2': lambda recs: time_format(sum([r.time_budget_mins or 0.
-                                                       for r in recs if r.tv])),
-        'style_getter': lambda col_index: [('ALIGN', (col_index, 0), (col_index, -1), 'CENTER'),
-                                           ('LINEBEFORE', (col_index, 0), (col_index, -1), 1., colors.black),
-                                           ('LINEAFTER', (col_index, 0), (col_index, -1), .5, colors.gray)],
+        'value_getter2': (lambda recs:
+                          time_format(sum([r.time_budget_mins or 0.
+                                           for r in recs if r.tv]))
+                          ),
+        'style_getter': (lambda col_index:
+                         [('ALIGN', (col_index, 0), (col_index, -1),
+                           'CENTER'),
+                          ('LINEBEFORE', (col_index, 0), (col_index, -1),
+                           1., colors.black),
+                          ('LINEAFTER', (col_index, 0), (col_index, -1),
+                           .5, colors.gray)]
+                         ),
        'width': num_column_width
    })

    columns.append({
        'heading': 'Opt',
        'value_getter': lambda recs: len([r for r in recs if r.optional]),
-        'value_getter2': lambda recs: time_format(sum([r.time_budget_mins or 0.
-                                                       for r in recs if r.optional])),
-        'style_getter': lambda col_index: [('ALIGN', (col_index, 0), (col_index, -1), 'CENTER'),
-                                           ('LINEAFTER', (col_index, 0), (col_index, -1), .5, colors.gray)],
+        'value_getter2': (lambda recs:
+                          time_format(sum([r.time_budget_mins or 0.
+                                           for r in recs if r.optional]))
+                          ),
+        'style_getter': (lambda col_index:
+                         [('ALIGN', (col_index, 0), (col_index, -1),
+                           'CENTER'),
+                          ('LINEAFTER', (col_index, 0), (col_index, -1),
+                           .5, colors.gray)]
+                         ),
        'width': num_column_width
    })

    columns.append({
        'heading': 'Eff',
        'value_getter': lambda recs: len([r for r in recs if r.effort]),
-        'value_getter2': lambda recs: time_format(sum([r.time_budget_mins or 0.
-                                                       for r in recs if r.effort])),
-        'style_getter': lambda col_index: [('ALIGN', (col_index, 0), (col_index, -1), 'CENTER')],
+        'value_getter2': (lambda recs:
+                          time_format(sum([r.time_budget_mins or 0.
+                                           for r in recs if r.effort]))
+                          ),
+        'style_getter': (lambda col_index:
+                         [('ALIGN', (col_index, 0), (col_index, -1),
+                           'CENTER')]
+                         ),
        'width': num_column_width
    })

@@ -80,23 +104,26 @@ def build_columns(lines: List[ADRLine], reel_list: Optional[List[str]], show_pri
    })

    if len(reel_numbers) > 0:
-        # columns.append({
-        #     'heading': 'RX',
-        #     'value_getter': lambda recs: blank_len([r for r in recs if 'Reel' not in r.keys()]),
-        #     'value_getter2': lambda recs: time_format(sum([r.get('Time Budget Mins', 0.) for r in recs
-        #                                                    if 'Reel' not in r.keys()])),
-        #     'style_getter': lambda col_index: [('ALIGN', (col_index, 0), (col_index, -1), 'CENTER')],
-        #     'width': num_column_width
-        # })

        for n in reel_numbers:
            columns.append({
                'heading': n,
-                'value_getter': lambda recs, n1=n: len([r for r in recs if r.reel == n1]),
-                'value_getter2': lambda recs, n1=n: time_format(sum([r.time_budget_mins or 0. for r
-                                                                     in recs if r.reel == n1])),
-                'style_getter': lambda col_index: [('ALIGN', (col_index, 0), (col_index, -1), 'CENTER'),
-                                                   ('LINEAFTER', (col_index, 0), (col_index, -1), .5, colors.gray)],
+                'value_getter': (lambda recs, n1=n:
+                                 len([r for r in recs if r.reel == n1])
+                                 ),
+                'value_getter2': (lambda recs, n1=n:
+                                  time_format(sum([r.time_budget_mins or 0.
+                                                   for r in recs
+                                                   if r.reel == n1]))
+                                  ),
+                'style_getter': (lambda col_index:
+                                 [('ALIGN', (col_index, 0), (col_index, -1),
+                                   'CENTER'),
+                                  ('LINEAFTER', (col_index, 0),
+                                   (col_index, -1),
+                                   .5, colors.gray)]
+                                 ),
+
                'width': num_column_width
            })

@@ -104,18 +131,26 @@ def build_columns(lines: List[ADRLine], reel_list: Optional[List[str]], show_pri
        for n in range(1, 6,):
            columns.append({
                'heading': 'P%i' % n,
-                'value_getter': lambda recs: len([r for r in recs if r.priority == n]),
-                'value_getter2': lambda recs: time_format(sum([r.time_budget_mins or 0.
-                                                               for r in recs if r.priority == n])),
+                'value_getter': lambda recs: len([r for r in recs
+                                                  if r.priority == n]),
+                'value_getter2': (lambda recs:
+                                  time_format(sum([r.time_budget_mins or 0.
+                                                   for r in recs
+                                                   if r.priority == n]))
+                                  ),
                'style_getter': lambda col_index: [],
                'width': num_column_width
            })

        columns.append({
            'heading': '>P5',
-            'value_getter': lambda recs: len([r for r in recs if (r.priority or 5) > 5]),
-            'value_getter2': lambda recs: time_format(sum([r.time_budget_mins or 0.
-                                                           for r in recs if (r.priority or 5) > 5])),
+            'value_getter': lambda recs: len([r for r in recs
+                                              if (r.priority or 5) > 5]),
+            'value_getter2': (lambda recs:
+                              time_format(sum([r.time_budget_mins or 0.
+                                               for r in recs
+                                               if (r.priority or 5) > 5]))
+                              ),
            'style_getter': lambda col_index: [],
            'width': num_column_width
        })
@@ -124,32 +159,47 @@ def build_columns(lines: List[ADRLine], reel_list: Optional[List[str]], show_pri
        columns.append({
            'heading': 'Omit',
            'value_getter': lambda recs: len([r for r in recs if r.omitted]),
-            'value_getter2': lambda recs: time_format(sum([r.time_budget_mins or 0.
-                                                           for r in recs if r.omitted])),
-            'style_getter': lambda col_index: [('ALIGN', (col_index, 0), (col_index, -1), 'CENTER')],
+            'value_getter2': (lambda recs:
+                              time_format(sum([r.time_budget_mins or 0.
+                                               for r in recs if r.omitted]))),
+            'style_getter': (lambda col_index:
+                             [('ALIGN', (col_index, 0), (col_index, -1),
+                               'CENTER')]
+                             ),
            'width': num_column_width
        })

    columns.append({
        'heading': 'Total',
        'value_getter': lambda recs: len([r for r in recs if not r.omitted]),
-        'value_getter2': lambda recs: time_format(sum([r.time_budget_mins or 0.
-                                                       for r in recs if not r.omitted]), zero_str=None),
-        'style_getter': lambda col_index: [('LINEBEFORE', (col_index, 0), (col_index, -1), 1.0, colors.black),
-                                           ('ALIGN', (col_index, 0), (col_index, -1), 'CENTER')],
+        'value_getter2': (lambda recs:
+                          time_format(
+                              sum([r.time_budget_mins or 0.
+
+                                   for r in recs if not r.omitted])
+                          )
+                          ),
+        'style_getter': (lambda col_index:
+                         [('LINEBEFORE', (col_index, 0), (col_index, -1),
+                           1.0, colors.black),
+                          ('ALIGN', (col_index, 0), (col_index, -1),
+                           'CENTER')]
+                         ),
        'width': 0.5 * inch
    })

    return columns


-def populate_columns(lines: List[ADRLine], columns, include_omitted, _page_size):
+def populate_columns(lines: List[ADRLine], columns, include_omitted,
+                     _page_size):
    data = list()
    styles = list()
    columns_widths = list()

-    sorted_character_numbers: List[str] = sorted(set([x.character_id for x in lines]),
-                                      key=lambda x: str(x))
+    sorted_character_numbers: List[str] = sorted(
+        set([x.character_id for x in lines]),
+        key=lambda x: str(x))

    # construct column styles

@@ -174,8 +224,10 @@ def populate_columns(lines: List[ADRLine], columns, include_omitted, _page_size)
                row_data.append(col['value_getter'](list(char_records)))
                row_data2.append(col['value_getter2'](list(char_records)))

-                styles.extend([('TEXTCOLOR', (0, row2_index), (-1, row2_index), colors.red),
-                               ('LINEBELOW', (0, row2_index), (-1, row2_index), 0.5, colors.black)])
+                styles.extend([('TEXTCOLOR', (0, row2_index), (-1, row2_index),
+                                colors.red),
+                               ('LINEBELOW', (0, row2_index), (-1, row2_index),
+                                0.5, colors.black)])

            data.append(row_data)
            data.append(row_data2)
@@ -192,7 +244,8 @@ def populate_columns(lines: List[ADRLine], columns, include_omitted, _page_size)
            summary_row1.append("")
            summary_row2.append("")

-    styles.append(('LINEABOVE', (0, row1_index), (-1, row1_index), 2.0, colors.black))
+    styles.append(('LINEABOVE', (0, row1_index), (-1, row1_index), 2.0,
+                   colors.black))

    data.append(summary_row1)
    data.append(summary_row2)
@@ -204,17 +257,20 @@ def populate_columns(lines: List[ADRLine], columns, include_omitted, _page_size)
 #     pass


-def output_report(lines: List[ADRLine], reel_list: List[str], include_omitted=False,
-                  page_size=portrait(letter), font_name='Helvetica'):
-    columns = build_columns(lines, include_omitted=include_omitted, reel_list=reel_list)
-    data, style, columns_widths = populate_columns(lines, columns, include_omitted, page_size)
+def output_report(lines: List[ADRLine], reel_list: List[str],
+                  include_omitted=False, page_size=portrait(letter),
+                  font_name='Helvetica'):
+    columns = build_columns(lines, include_omitted=include_omitted,
+                            reel_list=reel_list)
+    data, style, columns_widths = populate_columns(lines, columns,
+                                                   include_omitted, page_size)

    style.append(('FONTNAME', (0, 0), (-1, -1), font_name))
    style.append(('FONTSIZE', (0, 0), (-1, -1), 9.))
    style.append(('LINEBELOW', (0, 0), (-1, 0), 1.0, colors.black))
    # style.append(('LINEBELOW', (0, 1), (-1, -1), 0.25, colors.gray))

-    #pdfmetrics.registerFont(TTFont('Futura', 'Futura.ttc'))
+    # pdfmetrics.registerFont(TTFont('Futura', 'Futura.ttc'))

    title = "%s Line Count" % lines[0].title
    filename = title + '.pdf'
@@ -226,7 +282,8 @@ def output_report(lines: List[ADRLine], reel_list: List[str], include_omitted=Fa
                            document_header='Line Count')

    # header_data, header_style, header_widths = build_header(columns_widths)
-    # header_table = Table(data=header_data, style=header_style, colWidths=header_widths)
+    # header_table = Table(data=header_data, style=header_style,
+    # colWidths=header_widths)

    table = Table(data=data, style=style, colWidths=columns_widths)

@@ -241,6 +298,7 @@ def output_report(lines: List[ADRLine], reel_list: List[str], include_omitted=Fa
    omitted_count = len([x for x in lines if x.omitted])

    if not include_omitted and omitted_count > 0:
-        story.append(Paragraph("* %i Omitted lines are excluded." % omitted_count, style))
+        story.append(Paragraph("* %i Omitted lines are excluded." %
+                     omitted_count, style))

    doc.build(story)
--- a/ptulsconv/pdf/recordist_log.py
+++ b/ptulsconv/pdf/recordist_log.py
@@ -3,4 +3,4 @@
 def output_report(records):
    # order by start

-    pass
+    pass
--- a/ptulsconv/pdf/summary_log.py
+++ b/ptulsconv/pdf/summary_log.py
@@ -27,23 +27,28 @@ def build_aux_data_field(line: ADRLine):
    tag_field = ""
    if line.effort:
        bg_color = 'red'
-        tag_field += "<font backColor=%s textColor=%s fontSize=11>%s</font> " % (bg_color, fg_color, "EFF")
+        tag_field += "<font backColor=%s textColor=%s fontSize=11>%s</font> " \
+            % (bg_color, fg_color, "EFF")
    elif line.tv:
        bg_color = 'blue'
-        tag_field += "<font backColor=%s textColor=%s fontSize=11>%s</font> " % (bg_color, fg_color, "TV")
+        tag_field += "<font backColor=%s textColor=%s fontSize=11>%s</font> " \
+            % (bg_color, fg_color, "TV")
    elif line.adlib:
        bg_color = 'purple'
-        tag_field += "<font backColor=%s textColor=%s fontSize=11>%s</font> " % (bg_color, fg_color, "ADLIB")
+        tag_field += "<font backColor=%s textColor=%s fontSize=11>%s</font> " \
+            % (bg_color, fg_color, "ADLIB")
    elif line.optional:
        bg_color = 'green'
-        tag_field += "<font backColor=%s textColor=%s fontSize=11>%s</font>" % (bg_color, fg_color, "OPTIONAL")
+        tag_field += "<font backColor=%s textColor=%s fontSize=11>%s</font>" \
+            % (bg_color, fg_color, "OPTIONAL")

    entries.append(tag_field)

    return "<br />".join(entries)


-def build_story(lines: List[ADRLine], tc_rate: TimecodeFormat, font_name='Helvetica'):
+def build_story(lines: List[ADRLine], tc_rate: TimecodeFormat,
+                font_name='Helvetica'):
    story = list()

    this_scene = None
@@ -60,7 +65,8 @@ def build_story(lines: List[ADRLine], tc_rate: TimecodeFormat, font_name='Helvet
                       ('LEFTPADDING', (0, 0), (0, 0), 0.0),
                       ('BOTTOMPADDING', (0, 0), (-1, -1), 24.)]

-        cue_number_field = "%s<br /><font fontSize=7>%s</font>" % (line.cue_number, line.character_name)
+        cue_number_field = "%s<br /><font fontSize=7>%s</font>" \
+            % (line.cue_number, line.character_name)

        time_data = time_format(line.time_budget_mins)

@@ -79,7 +85,8 @@ def build_story(lines: List[ADRLine], tc_rate: TimecodeFormat, font_name='Helvet
                            ]]

        line_table = Table(data=line_table_data,
-                           colWidths=[inch * 0.75, inch, inch * 3., 0.5 * inch, inch * 2.],
+                           colWidths=[inch * 0.75, inch, inch * 3., 0.5 * inch,
+                                      inch * 2.],
                           style=table_style)

        if (line.scene or "[No Scene]") != this_scene:
@@ -97,7 +104,7 @@ def build_story(lines: List[ADRLine], tc_rate: TimecodeFormat, font_name='Helvet

 def build_tc_data(line: ADRLine, tc_format: TimecodeFormat):
    tc_data = tc_format.seconds_to_smpte(line.start) + "<br />" + \
-              tc_format.seconds_to_smpte(line.finish)
+        tc_format.seconds_to_smpte(line.finish)
    third_line = []
    if line.reel is not None:
        if line.reel[0:1] == 'R':
@@ -111,11 +118,12 @@ def build_tc_data(line: ADRLine, tc_format: TimecodeFormat):
    return tc_data


-def generate_report(page_size, lines: List[ADRLine], tc_rate: TimecodeFormat, character_number=None,
-                    include_omitted=True):
+def generate_report(page_size, lines: List[ADRLine], tc_rate: TimecodeFormat,
+                    character_number=None, include_omitted=True):
    if character_number is not None:
        lines = [r for r in lines if r.character_id == character_number]
-        title = "%s ADR Report (%s)" % (lines[0].title, lines[0].character_name)
+        title = "%s ADR Report (%s)" % (lines[0].title,
+                                        lines[0].character_name)
        document_header = "%s ADR Report" % lines[0].character_name
    else:
        title = "%s ADR Report" % lines[0].title
--- a/ptulsconv/pdf/supervisor_1pg.py
+++ b/ptulsconv/pdf/supervisor_1pg.py
@@ -1,7 +1,7 @@
 from reportlab.pdfgen.canvas import Canvas

-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
+# from reportlab.pdfbase import pdfmetrics
+# from reportlab.pdfbase.ttfonts import TTFont

 from reportlab.lib.units import inch
 from reportlab.lib.pagesizes import letter
@@ -11,20 +11,23 @@ from reportlab.platypus import Paragraph

 from .__init__ import GRect

-from ptulsconv.broadcast_timecode import TimecodeFormat, footage_to_frame_count
+from ptulsconv.broadcast_timecode import TimecodeFormat
 from ptulsconv.docparser.adr_entity import ADRLine

 import datetime

 font_name = 'Helvetica'

+
 def draw_header_block(canvas, rect, record: ADRLine):
-    rect.draw_text_cell(canvas, record.cue_number, "Helvetica", 44, vertical_align='m')
+    rect.draw_text_cell(canvas, record.cue_number, "Helvetica", 44,
+                        vertical_align='m')


 def draw_character_row(canvas, rect, record: ADRLine):
    label_frame, value_frame = rect.split_x(1.25 * inch)
-    label_frame.draw_text_cell(canvas, "CHARACTER", font_name, 10, force_baseline=9.)
+    label_frame.draw_text_cell(canvas, "CHARACTER", font_name, 10,
+                               force_baseline=9.)
    line = "%s / %s" % (record.character_id, record.character_name)
    if record.actor_name is not None:
        line = line + " / " + record.actor_name
@@ -33,7 +36,8 @@ def draw_character_row(canvas, rect, record: ADRLine):


 def draw_cue_number_block(canvas, rect, record: ADRLine):
-    (label_frame, number_frame,), aux_frame = rect.divide_y([0.20 * inch, 0.375 * inch], direction='d')
+    (label_frame, number_frame,), aux_frame = \
+        rect.divide_y([0.20 * inch, 0.375 * inch], direction='d')
    label_frame.draw_text_cell(canvas, "CUE NUMBER", font_name, 10,
                               inset_y=5., vertical_align='t')
    number_frame.draw_text_cell(canvas, record.cue_number, font_name, 14,
@@ -55,18 +59,25 @@ def draw_cue_number_block(canvas, rect, record: ADRLine):
    rect.draw_border(canvas, 'max_x')


-def draw_timecode_block(canvas, rect, record: ADRLine, tc_display_format: TimecodeFormat):
+def draw_timecode_block(canvas, rect, record: ADRLine,
+                        tc_display_format: TimecodeFormat):
    (in_label_frame, in_frame, out_label_frame, out_frame), _ = rect.divide_y(
        [0.20 * inch, 0.25 * inch, 0.20 * inch, 0.25 * inch], direction='d')

    in_label_frame.draw_text_cell(canvas, "IN", font_name, 10,
                                  vertical_align='t', inset_y=5., inset_x=5.)
-    in_frame.draw_text_cell(canvas, tc_display_format.seconds_to_smpte(record.start), font_name, 14,
-                            inset_x=10., inset_y=2., draw_baseline=True)
+    in_frame.draw_text_cell(canvas,
+                            tc_display_format.seconds_to_smpte(record.start),
+                            font_name, 14,
+                            inset_x=10., inset_y=2.,
+                            draw_baseline=True)
    out_label_frame.draw_text_cell(canvas, "OUT", font_name, 10,
                                   vertical_align='t', inset_y=5., inset_x=5.)
-    out_frame.draw_text_cell(canvas, tc_display_format.seconds_to_smpte(record.finish), font_name, 14,
-                             inset_x=10., inset_y=2., draw_baseline=True)
+    out_frame.draw_text_cell(canvas,
+                             tc_display_format.seconds_to_smpte(record.finish),
+                             font_name, 14,
+                             inset_x=10., inset_y=2.,
+                             draw_baseline=True)

    rect.draw_border(canvas, 'max_x')

@@ -91,13 +102,15 @@ def draw_reason_block(canvas, rect, record: ADRLine):

    p = Paragraph(record.note or "", style)

-    notes_value.draw_flowable(canvas, p, draw_baselines=True, inset_x=5., inset_y=5.)
+    notes_value.draw_flowable(canvas, p, draw_baselines=True,
+                              inset_x=5., inset_y=5.)


 def draw_prompt(canvas, rect, prompt=""):
    label, block = rect.split_y(0.20 * inch, direction='d')

-    label.draw_text_cell(canvas, "PROMPT", font_name, 10, vertical_align='t', inset_y=5., inset_x=0.)
+    label.draw_text_cell(canvas, "PROMPT", font_name, 10, vertical_align='t',
+                         inset_y=5., inset_x=0.)

    style = getSampleStyleSheet()['BodyText']
    style.fontName = font_name
@@ -117,7 +130,8 @@ def draw_prompt(canvas, rect, prompt=""):
 def draw_notes(canvas, rect, note=""):
    label, block = rect.split_y(0.20 * inch, direction='d')

-    label.draw_text_cell(canvas, "NOTES", font_name, 10, vertical_align='t', inset_y=5., inset_x=0.)
+    label.draw_text_cell(canvas, "NOTES", font_name, 10, vertical_align='t',
+                         inset_y=5., inset_x=0.)

    style = getSampleStyleSheet()['BodyText']
    style.fontName = font_name
@@ -169,31 +183,43 @@ def draw_take_grid(canvas, rect):
    canvas.restoreState()


-def draw_aux_block(canvas, rect, recording_time_sec_this_line, recording_time_sec):
+def draw_aux_block(canvas, rect, recording_time_sec_this_line,
+                   recording_time_sec):
    rect.draw_border(canvas, 'min_x')

    content_rect = rect.inset_xy(10., 10.)
-    lines, last_line = content_rect.divide_y([12., 12., 24., 24., 24., 24.], direction='d')
+    lines, last_line = content_rect.divide_y([12., 12., 24., 24., 24., 24.],
+                                             direction='d')

    lines[0].draw_text_cell(canvas,
-                            "Time for this line: %.1f mins" % (recording_time_sec_this_line / 60.), font_name, 9.)
-    lines[1].draw_text_cell(canvas, "Running time: %03.1f mins" % (recording_time_sec / 60.), font_name, 9.)
-    lines[2].draw_text_cell(canvas, "Actual Start: ______________", font_name, 9., vertical_align='b')
-    lines[3].draw_text_cell(canvas, "Record Date: ______________", font_name, 9., vertical_align='b')
-    lines[4].draw_text_cell(canvas, "Engineer: ______________", font_name, 9., vertical_align='b')
-    lines[5].draw_text_cell(canvas, "Location: ______________", font_name, 9., vertical_align='b')
+                            "Time for this line: %.1f mins" %
+                            (recording_time_sec_this_line / 60.),
+                            font_name, 9.)
+    lines[1].draw_text_cell(canvas, "Running time: %03.1f mins" %
+                            (recording_time_sec / 60.), font_name, 9.)
+    lines[2].draw_text_cell(canvas, "Actual Start: ______________",
+                            font_name, 9., vertical_align='b')
+    lines[3].draw_text_cell(canvas, "Record Date: ______________",
+                            font_name, 9., vertical_align='b')
+    lines[4].draw_text_cell(canvas, "Engineer: ______________",
+                            font_name, 9., vertical_align='b')
+    lines[5].draw_text_cell(canvas, "Location: ______________",
+                            font_name, 9., vertical_align='b')


-def draw_footer(canvas, rect, record: ADRLine, report_date, line_no, total_lines):
+def draw_footer(canvas, rect, record: ADRLine, report_date, line_no,
+                total_lines):
    rect.draw_border(canvas, 'max_y')
    report_date_s = [report_date.strftime("%c")]
    spotting_name = [record.spot] if record.spot is not None else []
    pages_s = ["Line %i of %i" % (line_no, total_lines)]
    footer_s = " - ".join(report_date_s + spotting_name + pages_s)
-    rect.draw_text_cell(canvas, footer_s, font_name=font_name, font_size=10., inset_y=2.)
+    rect.draw_text_cell(canvas, footer_s, font_name=font_name, font_size=10.,
+                        inset_y=2.)


-def create_report_for_character(records, report_date, tc_display_format: TimecodeFormat):
+def create_report_for_character(records, report_date,
+                                tc_display_format: TimecodeFormat):

    outfile = "%s_%s_%s_Log.pdf" % (records[0].title,
                                    records[0].character_id,
@@ -201,20 +227,24 @@ def create_report_for_character(records, report_date, tc_display_format: Timecod
    assert outfile is not None
    assert outfile[-4:] == '.pdf', "Output file must have 'pdf' extension!"

-    #pdfmetrics.registerFont(TTFont('Futura', 'Futura.ttc'))
+    # pdfmetrics.registerFont(TTFont('Futura', 'Futura.ttc'))

    page: GRect = GRect(0, 0, letter[0], letter[1])
    page = page.inset(inch * 0.5)
-    (header_row, char_row, data_row, prompt_row, notes_row, takes_row), footer = \
-        page.divide_y([0.875 * inch, 0.375 * inch, inch, 3.0 * inch, 1.5 * inch, 3 * inch], direction='d')
+    (header_row, char_row, data_row,
+     prompt_row, notes_row, takes_row), footer = \
+        page.divide_y([0.875 * inch, 0.375 * inch, inch,
+                       3.0 * inch, 1.5 * inch, 3 * inch], direction='d')

    cue_header_block, title_header_block = header_row.split_x(4.0 * inch)
-    (cue_number_block, timecode_block), reason_block = data_row.divide_x([1.5 * inch, 1.5 * inch])
+    (cue_number_block, timecode_block), reason_block = \
+        data_row.divide_x([1.5 * inch, 1.5 * inch])
    (take_grid_block), aux_block = takes_row.split_x(5.25 * inch)

    c = Canvas(outfile, pagesize=letter,)

-    c.setTitle("%s %s (%s) Supervisor's Log" % (records[0].title, records[0].character_name,
+    c.setTitle("%s %s (%s) Supervisor's Log" % (records[0].title,
+                                                records[0].character_name,
                                                records[0].character_id))
    c.setAuthor(records[0].supervisor)

@@ -223,7 +253,8 @@ def create_report_for_character(records, report_date, tc_display_format: Timecod
    line_n = 1
    for record in records:
        record: ADRLine
-        recording_time_sec_this_line: float = (record.time_budget_mins or 6.0) * 60.0
+        recording_time_sec_this_line: float = (
+            record.time_budget_mins or 6.0) * 60.0
        recording_time_sec = recording_time_sec + recording_time_sec_this_line

        draw_header_block(c, cue_header_block, record)
@@ -233,14 +264,17 @@ def create_report_for_character(records, report_date, tc_display_format: Timecod
        # draw_title_box(c, title_header_block, record)
        draw_character_row(c, char_row, record)
        draw_cue_number_block(c, cue_number_block, record)
-        draw_timecode_block(c, timecode_block, record, tc_display_format=tc_display_format)
+        draw_timecode_block(c, timecode_block, record,
+                            tc_display_format=tc_display_format)
        draw_reason_block(c, reason_block, record)
-        draw_prompt(c, prompt_row, prompt=record.prompt)
+        draw_prompt(c, prompt_row, prompt=record.prompt or "")
        draw_notes(c, notes_row, note="")
        draw_take_grid(c, take_grid_block)
-        draw_aux_block(c, aux_block, recording_time_sec_this_line, recording_time_sec)
+        draw_aux_block(c, aux_block, recording_time_sec_this_line,
+                       recording_time_sec)

-        draw_footer(c, footer, record, report_date, line_no=line_n, total_lines=total_lines)
+        draw_footer(c, footer, record, report_date, line_no=line_n,
+                    total_lines=total_lines)
        line_n = line_n + 1

        c.showPage()
@@ -254,5 +288,6 @@ def output_report(lines, tc_display_format: TimecodeFormat):
    character_numbers = set([x.character_id for x in lines])

    for n in character_numbers:
-        create_report_for_character([e for e in events if e.character_id == n], report_date,
+        create_report_for_character([e for e in events if e.character_id == n],
+                                    report_date,
                                    tc_display_format=tc_display_format)
--- a/ptulsconv/pdf/talent_sides.py
+++ b/ptulsconv/pdf/talent_sides.py
@@ -5,36 +5,42 @@ from .__init__ import make_doc_template
 from reportlab.lib.units import inch
 from reportlab.lib.pagesizes import letter

-from reportlab.platypus import Paragraph, Spacer, KeepTogether, Table, HRFlowable
+from reportlab.platypus import Paragraph, Spacer, KeepTogether, Table, \
+    HRFlowable
 from reportlab.lib.styles import getSampleStyleSheet
 from reportlab.lib import colors

-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
+# from reportlab.pdfbase import pdfmetrics
+# from reportlab.pdfbase.ttfonts import TTFont

 from ..broadcast_timecode import TimecodeFormat
 from ..docparser.adr_entity import ADRLine


-def output_report(lines: List[ADRLine], tc_display_format: TimecodeFormat, font_name="Helvetica"):
+def output_report(lines: List[ADRLine], tc_display_format: TimecodeFormat,
+                  font_name="Helvetica"):
    character_numbers = set([n.character_id for n in lines])
-    #pdfmetrics.registerFont(TTFont('Futura', 'Futura.ttc'))
+    # pdfmetrics.registerFont(TTFont('Futura', 'Futura.ttc'))

    for n in character_numbers:
-        char_lines = [line for line in lines if not line.omitted and line.character_id == n]
+        char_lines = [line for line in lines
+                      if not line.omitted and line.character_id == n]
        character_name = char_lines[0].character_name

        char_lines = sorted(char_lines, key=lambda line: line.start)

-        title = "%s (%s) %s ADR Script" % (char_lines[0].title, character_name, n)
-        filename = "%s_%s_%s_ADR Script.pdf" % (char_lines[0].title, n, character_name)
+        title = "%s (%s) %s ADR Script" % (char_lines[0].title,
+                                           character_name, n)
+        filename = "%s_%s_%s_ADR Script.pdf" % (char_lines[0].title,
+                                                n, character_name)

-        doc = make_doc_template(page_size=letter, filename=filename, document_title=title,
+        doc = make_doc_template(page_size=letter, filename=filename,
+                                document_title=title,
                                title=char_lines[0].title,
-                                document_subheader=char_lines[0].spot,
-                                supervisor=char_lines[0].supervisor,
-                                client=char_lines[0].client,
-                                document_header=character_name)
+                                document_subheader=char_lines[0].spot or "",
+                                supervisor=char_lines[0].supervisor or "",
+                                client=char_lines[0].client or "",
+                                document_header=character_name or "")

        story = []

@@ -58,7 +64,8 @@ def output_report(lines: List[ADRLine], tc_display_format: TimecodeFormat, font_
            start_tc = tc_display_format.seconds_to_smpte(line.start)
            finish_tc = tc_display_format.seconds_to_smpte(line.finish)
            data_block = [[Paragraph(line.cue_number, number_style),
-                           Paragraph(start_tc + " - " + finish_tc, number_style)
+                           Paragraph(start_tc + " - " + finish_tc,
+                                     number_style)
                           ]]

 # RIGHTWARDS ARROW →
--- a/ptulsconv/reporting.py
+++ b/ptulsconv/reporting.py
@@ -1,3 +1,9 @@
+"""
+Reporting logic. These methods provide reporting methods to the package and
+take some pains to provide nice-looking escape codes if we're writing to a
+tty.
+"""
+
 import sys


@@ -29,13 +35,15 @@ def print_warning(warning_string):
        sys.stderr.write(" - %s\n" % warning_string)


-def print_advisory_tagging_error(failed_string, position, parent_track_name=None, clip_time=None):
+def print_advisory_tagging_error(failed_string, position,
+                                 parent_track_name=None, clip_time=None):
    if sys.stderr.isatty():
        sys.stderr.write("\n")
        sys.stderr.write(" ! \033[33;1mTagging error: \033[0m")
        ok_string = failed_string[:position]
        not_ok_string = failed_string[position:]
-        sys.stderr.write("\033[32m\"%s\033[31;1m%s\"\033[0m\n" % (ok_string, not_ok_string))
+        sys.stderr.write("\033[32m\"%s\033[31;1m%s\"\033[0m\n" %
+                         (ok_string, not_ok_string))

        if parent_track_name is not None:
            sys.stderr.write(" !   > On track \"%s\"\n" % parent_track_name)
--- a/ptulsconv/validations.py
+++ b/ptulsconv/validations.py
@@ -1,3 +1,7 @@
+"""
+Validation logic for enforcing various consistency rules.
+"""
+
 from dataclasses import dataclass
 from ptulsconv.docparser.adr_entity import ADRLine
 from typing import Iterator, Optional
@@ -10,15 +14,20 @@ class ValidationError:

    def report_message(self):
        if self.event is not None:
-            return f"{self.message}: event at {self.event.start} with number {self.event.cue_number}"
+            return (f"{self.message}: event at {self.event.start} with number"
+                    "{self.event.cue_number}")
        else:
            return self.message


-def validate_unique_count(input_lines: Iterator[ADRLine], field='title', count=1):
+def validate_unique_count(input_lines: Iterator[ADRLine], field='title',
+                          count=1):
    values = set(list(map(lambda e: getattr(e, field), input_lines)))
    if len(values) > count:
-        yield ValidationError(message="Field {} has too many values (max={}): {}".format(field, count, values))
+        yield ValidationError(
+            message="Field {} has too many values (max={}): {}"
+            .format(field, count, values)
+        )


 def validate_value(input_lines: Iterator[ADRLine], key_field, predicate):
@@ -29,7 +38,8 @@ def validate_value(input_lines: Iterator[ADRLine], key_field, predicate):
                                  event=event)


-def validate_unique_field(input_lines: Iterator[ADRLine], field='cue_number', scope=None):
+def validate_unique_field(input_lines: Iterator[ADRLine], field='cue_number',
+                          scope=None):
    values = dict()
    for event in input_lines:
        this = getattr(event, field)
@@ -40,26 +50,31 @@ def validate_unique_field(input_lines: Iterator[ADRLine], field='cue_number', sc

        values.setdefault(key, set())
        if this in values[key]:
-            yield ValidationError(message='Re-used {}'.format(field), event=event)
+            yield ValidationError(message='Re-used {}'.format(field),
+                                  event=event)
        else:
            values[key].update(this)


-def validate_non_empty_field(input_lines: Iterator[ADRLine], field='cue_number'):
+def validate_non_empty_field(input_lines: Iterator[ADRLine],
+                             field='cue_number'):
    for event in input_lines:
        if getattr(event, field, None) is None:
-            yield ValidationError(message='Empty field {}'.format(field), event=event)
+            yield ValidationError(message='Empty field {}'.format(field),
+                                  event=event)


-def validate_dependent_value(input_lines: Iterator[ADRLine], key_field, dependent_field):
+def validate_dependent_value(input_lines: Iterator[ADRLine], key_field,
+                             dependent_field):
    """
-    Validates that two events with the same value in `key_field` always have the
-    same value in `dependent_field`
+    Validates that two events with the same value in `key_field` always have
+    the same value in `dependent_field`
    """
    key_values = set((getattr(x, key_field) for x in input_lines))

    for key_value in key_values:
-        rows = [(getattr(x, key_field), getattr(x, dependent_field)) for x in input_lines
+        rows = [(getattr(x, key_field), getattr(x, dependent_field))
+                for x in input_lines
                if getattr(x, key_field) == key_value]
        unique_rows = set(rows)
        if len(unique_rows) > 1:
--- a/ptulsconv/xml/common.py
+++ b/ptulsconv/xml/common.py
@@ -12,7 +12,10 @@ import ptulsconv
 from ptulsconv.docparser.adr_entity import ADRLine

 # TODO Get a third-party test for Avid Marker lists
-def avid_marker_list(lines: List[ADRLine], report_date=datetime.datetime.now(), reel_start_frame=0, fps=24):
+
+
+def avid_marker_list(lines: List[ADRLine], report_date=datetime.datetime.now(),
+                     reel_start_frame=0, fps=24):
    doc = TreeBuilder(element_factory=None)

    doc.start('Avid:StreamItems', {'xmlns:Avid': 'http://www.avid.com'})
@@ -48,26 +51,35 @@ def avid_marker_list(lines: List[ADRLine], report_date=datetime.datetime.now(),

    for line in lines:
        doc.start('AvClass', {'id': 'ATTR'})
-        doc.start('AvProp', {'id': 'ATTR', 'name': '__OMFI:ATTR:NumItems', 'type': 'int32'})
+        doc.start('AvProp', {'id': 'ATTR',
+                             'name': '__OMFI:ATTR:NumItems',
+                             'type': 'int32'})
        doc.data('7')
        doc.end('AvProp')

        doc.start('List', {'id': 'OMFI:ATTR:AttrRefs'})

-        insert_elem('1', 'OMFI:ATTB:IntAttribute', 'int32', '_ATN_CRM_LONG_CREATE_DATE', report_date.strftime("%s"))
-        insert_elem('2', 'OMFI:ATTB:StringAttribute', 'string', '_ATN_CRM_COLOR', 'yellow')
-        insert_elem('2', 'OMFI:ATTB:StringAttribute', 'string', '_ATN_CRM_USER', line.supervisor or "")
+        insert_elem('1', 'OMFI:ATTB:IntAttribute', 'int32',
+                    '_ATN_CRM_LONG_CREATE_DATE', report_date.strftime("%s"))
+        insert_elem('2', 'OMFI:ATTB:StringAttribute', 'string',
+                    '_ATN_CRM_COLOR', 'yellow')
+        insert_elem('2', 'OMFI:ATTB:StringAttribute', 'string',
+                    '_ATN_CRM_USER', line.supervisor or "")

        marker_name = "%s: %s" % (line.cue_number, line.prompt)
-        insert_elem('2', 'OMFI:ATTB:StringAttribute', 'string', '_ATN_CRM_COM', marker_name)
+        insert_elem('2', 'OMFI:ATTB:StringAttribute', 'string',
+                    '_ATN_CRM_COM', marker_name)

        start_frame = int(line.start * fps)

-        insert_elem('2', "OMFI:ATTB:StringAttribute", 'string', '_ATN_CRM_TC',
+        insert_elem('2', "OMFI:ATTB:StringAttribute", 'string',
+                    '_ATN_CRM_TC',
                    str(start_frame - reel_start_frame))

-        insert_elem('2', "OMFI:ATTB:StringAttribute", 'string', '_ATN_CRM_TRK', 'V1')
-        insert_elem('1', "OMFI:ATTB:IntAttribute", 'int32', '_ATN_CRM_LENGTH', '1')
+        insert_elem('2', "OMFI:ATTB:StringAttribute", 'string',
+                    '_ATN_CRM_TRK', 'V1')
+        insert_elem('1', "OMFI:ATTB:IntAttribute", 'int32',
+                    '_ATN_CRM_LENGTH', '1')

        doc.start('ListElem', {})
        doc.end('ListElem')
@@ -82,17 +94,22 @@ def avid_marker_list(lines: List[ADRLine], report_date=datetime.datetime.now(),
 def dump_fmpxml(data, input_file_name, output, adr_field_map):
    doc = TreeBuilder(element_factory=None)

-    doc.start('FMPXMLRESULT', {'xmlns': 'http://www.filemaker.com/fmpxmlresult'})
+    doc.start('FMPXMLRESULT', {'xmlns':
+                               'http://www.filemaker.com/fmpxmlresult'})

    doc.start('ERRORCODE', {})
    doc.data('0')
    doc.end('ERRORCODE')

-    doc.start('PRODUCT', {'NAME': ptulsconv.__name__, 'VERSION': ptulsconv.__version__})
+    doc.start('PRODUCT', {'NAME': ptulsconv.__name__,
+                          'VERSION': ptulsconv.__version__})
    doc.end('PRODUCT')

-    doc.start('DATABASE', {'DATEFORMAT': 'MM/dd/yy', 'LAYOUT': 'summary', 'TIMEFORMAT': 'hh:mm:ss',
-                           'RECORDS': str(len(data['events'])), 'NAME': os.path.basename(input_file_name)})
+    doc.start('DATABASE', {'DATEFORMAT': 'MM/dd/yy',
+                           'LAYOUT': 'summary',
+                           'TIMEFORMAT': 'hh:mm:ss',
+                           'RECORDS': str(len(data['events'])),
+                           'NAME': os.path.basename(input_file_name)})
    doc.end('DATABASE')

    doc.start('METADATA', {})
@@ -102,7 +119,8 @@ def dump_fmpxml(data, input_file_name, output, adr_field_map):
        if tp is int or tp is float:
            ft = 'NUMBER'

-        doc.start('FIELD', {'EMPTYOK': 'YES', 'MAXREPEAT': '1', 'NAME': field[1], 'TYPE': ft})
+        doc.start('FIELD', {'EMPTYOK': 'YES', 'MAXREPEAT': '1',
+                            'NAME': field[1], 'TYPE': ft})
        doc.end('FIELD')
    doc.end('METADATA')

@@ -157,7 +175,8 @@ def fmp_transformed_dump(data, input_file, xsl_name, output, adr_field_map):

    print_status_style("Running xsltproc")

-    xsl_path = os.path.join(pathlib.Path(__file__).parent.absolute(), 'xslt', xsl_name + ".xsl")
+    xsl_path = os.path.join(pathlib.Path(__file__).parent.absolute(), 'xslt',
+                            xsl_name + ".xsl")
    print_status_style("Using xsl: %s" % xsl_path)
    subprocess.run(['xsltproc', xsl_path, '-'],
                   input=str_data, text=True,
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -0,0 +1,53 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "ptulsconv"
+authors = [
+    {name = "Jamie Hardt", email = "jamiehardt@me.com"},
+]
+readme = "README.md"
+license = { file = "LICENSE" }
+classifiers = [
+    'License :: OSI Approved :: MIT License',
+    'Topic :: Multimedia',
+    'Topic :: Multimedia :: Sound/Audio',
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Development Status :: 5 - Production/Stable",
+    "Topic :: Text Processing :: Filters"
+]
+requires-python = ">=3.8"
+dynamic = ["version", "description"]
+keywords = ["text-processing", "parsers", "film", 
+    "broadcast", "editing", "editorial"]
+dependencies = [
+  'parsimonious',
+  'tqdm',
+  'reportlab',
+  'py-ptsl >= 101.1.0'
+  ]
+
+[project.optional-dependencies]
+doc = [
+    "Sphinx ~= 5.3.0",
+    "sphinx-rtd-theme >= 1.1.1"
+]
+
+[tool.flit.module]
+name = "ptulsconv"
+
+[project.scripts]
+ptulsconv = "ptulsconv.__main__:main"
+
+[project.entry_points.console_scripts]
+ptulsconv = 'ptulsconv.__main__:main'
+
+[project.urls]
+Source = 'https://github.com/iluvcapra/ptulsconv'
+Issues = 'https://github.com/iluvcapra/ptulsconv/issues'
+Documentation = 'https://ptulsconv.readthedocs.io/'
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,15 +0,0 @@
-astroid==2.9.3
-isort==5.10.1
-lazy-object-proxy==1.7.1
-mccabe==0.6.1
-parsimonious==0.9.0
-Pillow==9.1.1
-platformdirs==2.4.1
-pylint==2.12.2
-regex==2022.6.2
-reportlab==3.6.10
-six==1.16.0
-toml==0.10.2
-tqdm==4.64.0
-typing_extensions==4.0.1
-wrapt==1.13.3
--- a/setup.py
+++ b/setup.py
@@ -1,43 +0,0 @@
-from setuptools import setup
-
-from ptulsconv import __author__, __license__, __version__
-
-with open("README.md", "r") as fh:
-    long_description = fh.read()
-
-setup(name='ptulsconv',
-      version=__version__,
-      author=__author__,
-      description='Parse and convert Pro Tools text exports',
-      long_description_content_type="text/markdown",
-      long_description=long_description,
-      license=__license__,
-      url='https://github.com/iluvcapra/ptulsconv',
-      project_urls={
-          'Source':
-              'https://github.com/iluvcapra/ptulsconv',
-          'Issues':
-              'https://github.com/iluvcapra/ptulsconv/issues',
-      },
-      classifiers=[
-          'License :: OSI Approved :: MIT License',
-          'Topic :: Multimedia',
-          'Topic :: Multimedia :: Sound/Audio',
-          "Programming Language :: Python :: 3.7",
-          "Programming Language :: Python :: 3.8",
-          "Programming Language :: Python :: 3.9",
-          "Programming Language :: Python :: 3.10",
-          "Development Status :: 4 - Beta",
-          "Topic :: Text Processing :: Filters"],
-      packages=['ptulsconv'],
-      keywords='text-processing parsers film tv editing editorial',
-      install_requires=['parsimonious', 'tqdm', 'reportlab'],
-      package_data={
-          "ptulsconv": ["xslt/*.xsl"]
-      },
-      entry_points={
-          'console_scripts': [
-              'ptulsconv = ptulsconv.__main__:main'
-          ]
-      }
-      )
--- a/test-coverage.sh
+++ b/test-coverage.sh
@@ -1,4 +0,0 @@
-#!/bin/bash
-
-coverage run -m pytest . ; coverage-lcov
-
--- a/tests/export_cases/Test
+++ b/tests/export_cases/Test
@@ -0,0 +1,24 @@
+SESSION NAME:	Test for ptulsconv
+SAMPLE RATE:	48000.000000
+BIT DEPTH:	24-bit
+SESSION START TIMECODE:	00:00:00:00
+TIMECODE FORMAT:	23.976 Frame
+# OF AUDIO TRACKS:	1
+# OF AUDIO CLIPS:	0
+# OF AUDIO FILES:	0
+
+
+T R A C K  L I S T I N G
+TRACK NAME:	Hamlet
+COMMENTS:	{Actor=Laurence Olivier}
+USER DELAY:	0 Samples
+STATE: 
+CHANNEL 	EVENT   	CLIP NAME                     	START TIME    	END TIME      	DURATION      	STATE
+1       	1       	Test Line 1 $QN=T1001         	   00:00:00:00	   00:00:02:00	   00:00:02:00	Unmuted
+1       	2       	Test Line 2 $QN=T1002         	   00:00:04:00	   00:00:06:00	   00:00:02:00	Unmuted
+
+
+M A R K E R S  L I S T I N G
+#   	LOCATION     	TIME REFERENCE    	UNITS    	NAME                             	TRACK NAME                       	TRACK TYPE   	COMMENTS
+1   	00:00:00:00  	0                 	Samples  	{Title=Multiple Marker Rulers Project}	Markers                          	Ruler                            	
+2   	00:00:04:00  	192192            	Samples  	Track Marker                     	Hamlet                           	Track                            	
--- a/tests/export_tests/test_robinhood1.py
+++ b/tests/export_tests/test_robinhood1.py
@@ -7,8 +7,8 @@ class TestRobinHood1(unittest.TestCase):
    path = os.path.dirname(__file__) + '/../export_cases/Robin Hood Spotting.txt'

    def test_header_export(self):
-
-        session = parse_document(self.path)
+        with open(self.path,"r") as file:
+            session = parse_document(file.read())

        self.assertIsNotNone(session.header)
        self.assertEqual(session.header.session_name, 'Robin Hood Spotting')
@@ -19,7 +19,8 @@ class TestRobinHood1(unittest.TestCase):

    def test_all_sections(self):

-        session = parse_document(self.path)
+        with open(self.path,"r") as file:
+            session = parse_document(file.read())

        self.assertIsNotNone(session.header)
        self.assertIsNotNone(session.files)
@@ -30,7 +31,8 @@ class TestRobinHood1(unittest.TestCase):

    def test_tracks(self):

-        session = parse_document(self.path)
+        with open(self.path,"r") as file:
+            session = parse_document(file.read())

        self.assertEqual(len(session.tracks), 14)
        self.assertListEqual(["Scenes", "Robin", "Will", "Marian", "John",
@@ -54,7 +56,10 @@ class TestRobinHood1(unittest.TestCase):
                             list(map(lambda t: t.comments, session.tracks)))

    def test_a_track(self):
-        session = parse_document(self.path)
+
+        with open(self.path,"r") as file:
+            session = parse_document(file.read())
+        
        guy_track = session.tracks[5]
        self.assertEqual(guy_track.name, 'Guy')
        self.assertEqual(guy_track.comments, '[ADR] {Actor=Basil Rathbone} $CN=5')
@@ -71,7 +76,8 @@ class TestRobinHood1(unittest.TestCase):
        self.assertEqual(guy_track.clips[5].state, 'Unmuted')

    def test_memory_locations(self):
-        session = parse_document(self.path)
+        with open(self.path,"r") as file:
+            session = parse_document(file.read())

        self.assertEqual(len(session.markers), 1)
        self.assertEqual(session.markers[0].number, 1)
--- a/tests/export_tests/test_robinhood5.py
+++ b/tests/export_tests/test_robinhood5.py
@@ -7,23 +7,30 @@ class TestRobinHood5(unittest.TestCase):
    path = os.path.dirname(__file__) + '/../export_cases/Robin Hood Spotting5.txt'

    def test_skipped_segments(self):
-        session = parse_document(self.path)
+        with open(self.path,"r") as file:
+            session = parse_document(file.read())
+
        self.assertIsNone(session.files)
        self.assertIsNone(session.clips)

    def test_plugins(self):
-        session = parse_document(self.path)
+        with open(self.path,"r") as file:
+            session = parse_document(file.read())
+
        self.assertEqual(len(session.plugins), 2)

    def test_stereo_track(self):
-        session = parse_document(self.path)
+        with open(self.path,"r") as file:
+            session = parse_document(file.read())
+
        self.assertEqual(session.tracks[1].name, 'MX WT (Stereo)')
        self.assertEqual(len(session.tracks[1].clips), 2)
        self.assertEqual(session.tracks[1].clips[0].clip_name, 'RobinHood.1-01.L')
        self.assertEqual(session.tracks[1].clips[1].clip_name, 'RobinHood.1-01.R')

    def test_a_track(self):
-        session = parse_document(self.path)
+        with open(self.path,"r") as file:
+            session = parse_document(file.read())

        guy_track = session.tracks[8]
        self.assertEqual(guy_track.name, 'Guy')
--- a/tests/export_tests/test_robinhood6.py
+++ b/tests/export_tests/test_robinhood6.py
@@ -7,7 +7,9 @@ class TestRobinHood6(unittest.TestCase):
    path = os.path.dirname(__file__) + '/../export_cases/Robin Hood Spotting6.txt'

    def test_a_track(self):
-        session = parse_document(self.path)
+        with open(self.path, "r") as file:
+            session = parse_document(file.read())
+

        marian_track = session.tracks[6]
        self.assertEqual(marian_track.name, 'Marian')
--- a/tests/export_tests/test_robinhooddf.py
+++ b/tests/export_tests/test_robinhooddf.py
@@ -7,11 +7,16 @@ class TestRobinHoodDF(unittest.TestCase):
    path = os.path.dirname(__file__) + '/../export_cases/Robin Hood SpottingDF.txt'

    def test_header_export_df(self):
-        session = parse_document(self.path)
+        
+        with open(self.path, "r") as file:
+            session = parse_document(file.read())
+        
        self.assertEqual(session.header.timecode_drop_frame, True)

    def test_a_track(self):
-        session = parse_document(self.path)
+
+        with open(self.path, "r") as file:
+            session = parse_document(file.read())

        guy_track = session.tracks[4]
        self.assertEqual(guy_track.name, 'Robin')
--- a/tests/functional/test_pdf_export.py
+++ b/tests/functional/test_pdf_export.py
@@ -2,33 +2,52 @@ import unittest

 import tempfile

+import sys
 import os.path
 import os
 import glob
-
 from ptulsconv import commands

-class TestBroadcastTimecode(unittest.TestCase):
+
+class TestPDFExport(unittest.TestCase):
    def test_report_generation(self):
        """
        Setp through every text file in export_cases and make sure it can 
        be converted into PDF docs without throwing an error
        """
-        files = [os.path.dirname(__file__) + "/../export_cases/Robin Hood Spotting.txt"] 
-        #files.append(os.path.dirname(__file__) + "/../export_cases/Robin Hood Spotting2.txt")
+        files = []
+        files = [os.path.dirname(__file__) +
+                 "/../export_cases/Robin Hood Spotting.txt"]
        for path in files:
            tempdir = tempfile.TemporaryDirectory()
            os.chdir(tempdir.name)
            try:
-                commands.convert(path, major_mode='doc')
-            except:
-                assert False, "Error processing file %s" % path
+                commands.convert(input_file=path, major_mode='doc')
+            except Exception as e:
+                print("Error in test_report_generation")
+                print(f"File: {path}")
+                print(repr(e))
+                raise e
+            finally:
+                tempdir.cleanup()
+
+    def test_report_generation_track_markers(self):
+        files = []
+        files.append(os.path.dirname(__file__) +
+                     "/../export_cases/Test for ptulsconv.txt")
+        for path in files:
+            tempdir = tempfile.TemporaryDirectory()
+            os.chdir(tempdir.name)
+            try:
+                commands.convert(input_file=path, major_mode='doc')
+            except Exception as e:
+                print("Error in test_report_generation_track_markers")
+                print(f"File: {path}")
+                print(repr(e))
+                raise e
            finally:
                tempdir.cleanup()


-
-
-
 if __name__ == '__main__':
    unittest.main()
--- a/tests/unittests/test_broadcast_timecode.py
+++ b/tests/unittests/test_broadcast_timecode.py
@@ -70,6 +70,16 @@ class TestBroadcastTimecode(unittest.TestCase):
        s1 = tc_format.seconds_to_smpte(secs)
        self.assertEqual(s1, "00:00:01:01")

+    def test_unparseable_footage(self):
+        time_str = "10.1"
+        s1 = broadcast_timecode.footage_to_frame_count(time_str)
+        self.assertIsNone(s1)
+
+    def test_unparseable_timecode(self):
+        time_str = "11.32-19"
+        s1 = broadcast_timecode.smpte_to_frame_count(time_str, frames_per_logical_second=24)
+        self.assertIsNone(s1)
+

 if __name__ == '__main__':
    unittest.main()
--- a/tests/unittests/test_tag_compiler.py
+++ b/tests/unittests/test_tag_compiler.py
@@ -88,7 +88,9 @@ class TestTagCompiler(unittest.TestCase):
                                           state='Unmuted',
                                           timestamp=None),
        ]
-        test_track = doc_entity.TrackDescriptor(name="Track 1 [A] {Color=Red} $Mode=1",
+        test_track = doc_entity.TrackDescriptor(
+            index=0,
+            name="Track 1 [A] {Color=Red} $Mode=1",
                                                comments="{Comment=This is some text in the comments}",
                                                user_delay_samples=0,
                                                plugins=[],
@@ -100,14 +102,14 @@ class TestTagCompiler(unittest.TestCase):
                                               time_reference=48000 * 3600,
                                               units="Samples",
                                               name="Marker 1 {Part=1}",
-                                               comments=""
+                                               comments="", track_marker=False,
                                               ),
                   doc_entity.MarkerDescriptor(number=2,
                                               location="01:00:01:00",
                                               time_reference=48000 * 3601,
                                               units="Samples",
                                               name="Marker 2 {Part=2}",
-                                               comments="[M1]"
+                                               comments="[M1]", track_marker=False,
                                               ),
                   ]

--- a/tests/unittests/test_tagging.py
+++ b/tests/unittests/test_tagging.py
@@ -1,5 +1,5 @@
 import unittest
-from ptulsconv.docparser import doc_entity, doc_parser_visitor, ptuls_grammar, tag_compiler
+from ptulsconv.docparser import doc_entity, pt_doc_parser, tag_compiler
 import os.path


@@ -8,8 +8,8 @@ class TaggingIntegratedTests(unittest.TestCase):

    def test_event_list(self):
        with open(self.path, 'r') as f:
-            document_ast = ptuls_grammar.protools_text_export_grammar.parse(f.read())
-            document: doc_entity.SessionDescriptor = doc_parser_visitor.DocParserVisitor().visit(document_ast)
+            document_ast = pt_doc_parser.protools_text_export_grammar.parse(f.read())
+            document: doc_entity.SessionDescriptor = pt_doc_parser.DocParserVisitor().visit(document_ast)
            compiler = tag_compiler.TagCompiler()
            compiler.session = document

@@ -28,8 +28,8 @@ class TaggingIntegratedTests(unittest.TestCase):

    def test_append(self):
        with open(self.path, 'r') as f:
-            document_ast = ptuls_grammar.protools_text_export_grammar.parse(f.read())
-            document: doc_entity.SessionDescriptor = doc_parser_visitor.DocParserVisitor().visit(document_ast)
+            document_ast = pt_doc_parser.protools_text_export_grammar.parse(f.read())
+            document: doc_entity.SessionDescriptor = pt_doc_parser.DocParserVisitor().visit(document_ast)
            compiler = tag_compiler.TagCompiler()
            compiler.session = document

@@ -51,8 +51,8 @@ class TaggingIntegratedTests(unittest.TestCase):

    def test_successive_appends(self):
        with open(self.path, 'r') as f:
-            document_ast = ptuls_grammar.protools_text_export_grammar.parse(f.read())
-            document: doc_entity.SessionDescriptor = doc_parser_visitor.DocParserVisitor().visit(document_ast)
+            document_ast = pt_doc_parser.protools_text_export_grammar.parse(f.read())
+            document: doc_entity.SessionDescriptor = pt_doc_parser.DocParserVisitor().visit(document_ast)
            compiler = tag_compiler.TagCompiler()
            compiler.session = document
Author	SHA1	Message	Date
Jamie Hardt	aa7b418121	Update __init__.py Nudging version to 2.2.1	2025-05-24 21:58:50 -07:00
Jamie Hardt	a519a525b2	Update pythonpublish.yml Updating python publish action to the latest version	2025-05-24 21:54:42 -07:00
Jamie Hardt	1412efe509	autopep	2025-05-18 13:39:06 -07:00
Jamie Hardt	12a6c05467	autopep	2025-05-18 13:37:46 -07:00
Jamie Hardt	cf87986014	autopep'd test	2025-05-18 13:35:12 -07:00
Jamie Hardt	67533879f8	Rewrote parsing to handle old & new-style markers	2025-05-18 13:33:51 -07:00
Jamie Hardt	f847b88aa3	Nudged version and copyright date	2025-05-17 12:06:56 -07:00
Jamie Hardt	c3a600c5d7	Integrated track marker test case and fixed parser	2025-05-17 12:05:27 -07:00
Jamie Hardt	914783a809	Updated documentation	2025-05-17 11:26:07 -07:00
Jamie Hardt	c638c673e8	Adding track marker export case	2025-05-17 11:23:54 -07:00
Jamie Hardt	15fe6667af	Fixed up unit test	2025-05-17 11:23:02 -07:00
Jamie Hardt	d4e23b59eb	Adding support for track markers (Always ignore for now)	2025-05-17 11:19:22 -07:00
Jamie Hardt	a602b09551	flake8	2025-05-17 10:47:21 -07:00
Jamie Hardt	448d93d717	Fix for flake	2025-05-17 10:45:40 -07:00
Jamie Hardt	59e7d40d97	Merge branch 'master' of https://github.com/iluvcapra/ptulsconv	2025-05-11 22:19:26 -07:00
Jamie Hardt	eaa5fe824f	Fixed parser logic to handle new-style marker tracks	2025-05-11 22:17:42 -07:00
Jamie Hardt	8ebfd32e02	Update __init__.py Nudge version	2024-07-10 21:16:45 -07:00
Jamie Hardt	83a9adb48a	Merge remote-tracking branch 'refs/remotes/origin/master'	2023-11-15 23:09:27 -08:00
Jamie Hardt	013ebcbe75	movie options	2023-11-15 23:09:12 -08:00
Jamie Hardt	c87695e5fe	Merge pull request #12 from iluvcapra/maint-py312 Add Python 3.12 support	2023-11-08 10:33:13 -08:00
Jamie Hardt	4a8983cbbb	Update python-package.yml Added 3.12 to test matrix	2023-11-08 10:27:56 -08:00
Jamie Hardt	9123cbd0b5	Update pyproject.toml Added 3.12 classifier	2023-11-08 10:27:04 -08:00
Jamie Hardt	4224d106b0	Fixed compyright notice	2023-11-04 11:50:03 -07:00
Jamie Hardt	ac22fab97f	Some style fixes (all E231)	2023-11-04 11:36:34 -07:00
Jamie Hardt	64ca2c6c5c	Silenced some more errors	2023-11-04 11:23:40 -07:00
Jamie Hardt	c3af30dc6a	Renamed my JSONEncoder something useful	2023-11-04 11:21:59 -07:00
Jamie Hardt	c30f675cec	Cleared up a type warning	2023-11-04 11:17:48 -07:00
Jamie Hardt	204af7d9cb	A bunch of typo cleanups and styling.	2023-11-04 11:13:49 -07:00
Jamie Hardt	10fc211e80	Some typos	2023-11-04 10:56:44 -07:00
Jamie Hardt	d56c7df376	Updated documentation to reflect current usage No longer have to output a text export. Some formatting changes.	2023-11-04 10:49:56 -07:00
Jamie Hardt	7b38449a5f	Fixed formatting of a list.	2023-11-04 10:43:21 -07:00
Jamie Hardt	17b87b6e69	Update __init__.py Nudged version	2023-07-27 23:23:39 -07:00
Jamie Hardt	a636791539	Autopep	2023-07-27 23:17:23 -07:00
Jamie Hardt	dfde3c4493	Fixed errors with track_index field In tests	2023-07-27 23:15:49 -07:00
Jamie Hardt	81909c8a51	Added track index to TrackDescriptor to indicate a track's import order.	2023-07-27 22:58:06 -07:00
Jamie Hardt	e2b9a20870	Added some documentation	2023-07-27 22:10:29 -07:00
Jamie Hardt	006cec05e5	Merge pull request #10 from iluvcapra/bug-flake8 Flake8 code cleanups and a bug fix	2023-07-22 13:01:15 -07:00
Jamie Hardt	a95f0b5cca	Nudged version number	2023-07-22 12:58:32 -07:00
Jamie Hardt	70a5206d73	Fixed dumb typo that made ptsl break	2023-07-21 22:21:48 -07:00
Jamie Hardt	128eed002d	Update README.md	2023-07-21 14:54:54 -07:00
Jamie Hardt	f8a0d70942	Update README.md Dumb typo in "last commit" badge	2023-07-21 14:54:23 -07:00
Jamie Hardt	5f29e95ba9	Merge pull request #8 from iluvcapra/bug-flake8 Add Flake8 to build tests, clean up code style	2023-07-21 14:26:53 -07:00
Jamie Hardt	82f07b13a6	Do not warn on unsued imports in __init__	2023-07-21 14:25:17 -07:00
Jamie Hardt	fbcbba1098	flake8	2023-07-21 14:20:35 -07:00
Jamie Hardt	622f04963f	Update python-package.yml Added flake8 to the build	2023-07-21 14:04:35 -07:00
Jamie Hardt	5b36dcb5aa	flake8	2023-07-21 14:03:05 -07:00
Jamie Hardt	fd02d962d0	flake8	2023-07-21 13:45:47 -07:00
Jamie Hardt	2021159666	flake8 fixes	2023-07-21 13:38:24 -07:00
Jamie Hardt	f825b92586	Flake8 cleanups	2023-07-21 13:21:01 -07:00
Jamie Hardt	4318946596	Merge pull request #7 from iluvcapra/require-py-3.8 Eliminate Python 3.7 Support	2023-07-21 12:57:46 -07:00
Jamie Hardt	2a98954885	Update __init__.py	2023-07-21 12:56:13 -07:00
Jamie Hardt	79d8cc5b69	Update python-package.yml	2023-07-21 12:53:43 -07:00
Jamie Hardt	5785dc3364	Update pyproject.toml Requires Python 3.8	2023-07-21 12:51:12 -07:00
Jamie Hardt	4e64edcd85	Updated tests	2023-07-21 12:44:42 -07:00
Jamie Hardt	58277367c5	Implemeneted direct reading session data with PTSL	2023-07-21 12:33:59 -07:00
Jamie Hardt	617f34a515	Fixing publish script to use pypi	2023-06-02 19:37:12 -07:00
Jamie Hardt	5427b4cfb1	BUmped version number and copyright	2023-06-02 19:25:07 -07:00
Jamie Hardt	408829e820	Fixed numerous errors with build	2023-06-02 19:23:07 -07:00
Jamie Hardt	b65401d25f	Fixing doc build	2023-02-28 12:24:30 -08:00
Jamie Hardt	50fe3e2c0a	Fixing doc build	2023-02-28 12:21:39 -08:00
Jamie Hardt	1c8feec8fe	Added description to module	2023-02-28 10:52:19 -08:00
Jamie Hardt	f510f98ede	Bump vers	2023-02-28 10:50:17 -08:00
Jamie Hardt	ddf1948f3c	Upgraded to pyproject/flit build style	2023-02-28 10:49:52 -08:00
Jamie Hardt	1c9d373b40	Merge pull request #6 from iluvcapra/dependabot/pip/docs/certifi-2022.12.7 Bump certifi from 2022.9.24 to 2022.12.7 in /docs	2022-12-09 09:07:18 -08:00
dependabot[bot]	51b2517db1	Bump certifi from 2022.9.24 to 2022.12.7 in /docs Bumps [certifi](https://github.com/certifi/python-certifi) from 2022.9.24 to 2022.12.7. - [Release notes](https://github.com/certifi/python-certifi/releases) - [Commits](https://github.com/certifi/python-certifi/compare/2022.09.24...2022.12.07) --- updated-dependencies: - dependency-name: certifi dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2022-12-09 09:23:51 +00:00
Jamie Hardt	27dd8bc94d	Merge branch 'master' of https://github.com/iluvcapra/ptulsconv	2022-11-20 20:24:05 -08:00
Jamie Hardt	dd394a8fec	Reading project metadata from project	2022-11-20 20:23:51 -08:00
Jamie Hardt	b5571891cf	Update setup.py	2022-11-20 19:08:13 -08:00
Jamie Hardt	73058e9423	Update python-package.yml Adding Python 3.11 to the build matrix	2022-11-20 19:06:10 -08:00
Jamie Hardt	a11cda40e5	Update pythonpublish.yml	2022-11-20 14:14:26 -08:00
Jamie Hardt	7381a37185	Update pythonpublish.yml Added hashtags to mastodon message	2022-11-20 14:13:58 -08:00
Jamie Hardt	065bd26f4c	Refactored symbol	2022-11-20 13:31:10 -08:00
Jamie Hardt	7ec983f63f	Refactored file name	2022-11-20 13:21:15 -08:00
Jamie Hardt	944e66728b	Added some tests	2022-11-20 13:14:20 -08:00
Jamie Hardt	6473c83785	.gitignore	2022-11-20 13:03:34 -08:00
Jamie Hardt	8947d409b4	Delete .vim directory	2022-11-20 13:02:26 -08:00
Jamie Hardt	0494e771be	Delete .vscode directory	2022-11-20 13:02:18 -08:00
Jamie Hardt	f00bea8702	Merge branch 'master' of https://github.com/iluvcapra/ptulsconv	2022-11-20 12:55:18 -08:00
Jamie Hardt	6e82a14e4f	Cleaned up requirements	2022-11-20 12:55:03 -08:00
Jamie Hardt	07669e4eca	Update pythonpublish.yml Added post to Mastodon	2022-11-20 10:53:35 -08:00
Jamie Hardt	ddc406b1eb	Update toot.yml	2022-11-20 10:35:29 -08:00
Jamie Hardt	e07b3bb604	Update toot.yml	2022-11-20 10:28:13 -08:00
Jamie Hardt	c02453d10f	Create toot.yml	2022-11-20 10:18:45 -08:00
Jamie Hardt	cdc8a838ac	Update pythonpublish.yml	2022-11-20 10:12:53 -08:00
Jamie Hardt	e2c7408413	Update pythonpublish.yml	2022-11-20 10:08:52 -08:00
Jamie Hardt	a18154edb0	Update README.md	2022-11-20 08:25:06 -08:00
Jamie Hardt	f15ee40d37	Update README.md	2022-11-20 08:18:53 -08:00
Jamie Hardt	cd26be0c20	unfreezing importlib	2022-11-19 21:42:10 -08:00
Jamie Hardt	d50e45882b	Trying to make refs look nice	2022-11-19 21:37:50 -08:00
Jamie Hardt	adb80eb174	Merge branch 'master' of https://github.com/iluvcapra/ptulsconv	2022-11-19 19:04:55 -08:00
Jamie Hardt	2b91f128b9	Refactoring	2022-11-19 19:04:53 -08:00
Jamie Hardt	9f24d45f25	Documentation	2022-11-19 19:02:47 -08:00
Jamie Hardt	3a58fdba75	Some refactoring	2022-11-19 14:47:26 -08:00
Jamie Hardt	800a4dfb12	Adjust warnings	2022-11-19 14:10:30 -08:00
Jamie Hardt	6bc98063db	Freeze importlib	2022-11-19 14:04:34 -08:00
Jamie Hardt	b1bf49ca82	Update LICENSE	2022-11-19 00:00:15 -08:00
Jamie Hardt	61250aaf63	Dev docs	2022-11-18 21:26:50 -08:00
Jamie Hardt	43df2c1558	Adding the whole requirements	2022-11-18 20:50:09 -08:00
Jamie Hardt	17dc868756	Hide doc from parent	2022-11-18 20:46:59 -08:00
Jamie Hardt	2e36a789b4	Twiddle docs	2022-11-18 20:39:53 -08:00
Jamie Hardt	1345113a85	Documentation	2022-11-18 20:18:26 -08:00
Jamie Hardt	76c2e24084	Developer documentation	2022-11-18 19:32:00 -08:00
Jamie Hardt	a5ed16849c	Documentation	2022-11-18 19:18:08 -08:00
Jamie Hardt	4c3e103e77	Test refinements	2022-11-18 19:09:37 -08:00
Jamie Hardt	dd767b2d41	Merge branches 'master' and 'master' of https://github.com/iluvcapra/ptulsconv	2022-11-18 18:51:48 -08:00
Jamie Hardt	aaf751c1a2	Reorganized docs into folders	2022-11-18 18:51:45 -08:00
Jamie Hardt	91e0da278f	Delete .idea directory	2022-11-18 18:47:36 -08:00
Jamie Hardt	a7d01779bd	Doc twiddle	2022-11-18 18:44:41 -08:00
Jamie Hardt	cb6c0c8895	Doc tweaks	2022-11-18 18:38:44 -08:00
Jamie Hardt	a2a6782214	Added note	2022-11-18 18:36:35 -08:00
Jamie Hardt	2c78d4a09d	Directive implementation	2022-11-18 18:33:51 -08:00
Jamie Hardt	28cf7b5d09	Directive parsing	2022-11-18 16:59:39 -08:00
Jamie Hardt	b419814f82	Doc updates	2022-11-18 16:51:56 -08:00
Jamie Hardt	967ef5c63a	Developer docs	2022-11-18 16:26:55 -08:00
Jamie Hardt	fe1a1eebd5	Docs	2022-11-18 16:20:18 -08:00
Jamie Hardt	dadeab49fe	New feature doc	2022-11-18 16:14:55 -08:00
Jamie Hardt	900dd5d582	More doc work	2022-11-18 15:37:02 -08:00
Jamie Hardt	5882e01b31	Updated requirements for doc	2022-11-18 15:36:54 -08:00
Jamie Hardt	e2e86faf54	Documentation	2022-11-18 13:03:37 -08:00
Jamie Hardt	bfdefc8da0	Documentation	2022-11-18 12:23:31 -08:00
Jamie Hardt	2af9317e7e	Removed refs to CSV Added more text.	2022-11-18 11:45:58 -08:00
Jamie Hardt	9194e5ba54	Merge branch 'master' of https://github.com/iluvcapra/ptulsconv	2022-11-18 11:34:11 -08:00
Jamie Hardt	528bd949ca	Restructuring documenation Swiching to readthedocs.io	2022-11-18 11:33:47 -08:00
Jamie Hardt	5633eb89f0	Update README.md	2022-11-16 21:05:03 -08:00
Jamie Hardt	29e1753b18	Tweaking this code to silence errors in the github build	2022-11-15 12:28:50 -08:00
Jamie Hardt	1df0b79ab6	Tweaked tag parsing	2022-11-15 12:26:06 -08:00
Jamie Hardt	68db6c9b09	Merge branch 'master' of https://github.com/iluvcapra/ptulsconv	2022-11-15 12:15:45 -08:00
Jamie Hardt	2c664db0dd	Updated requirements with latest stuff	2022-11-15 12:14:28 -08:00
Jamie Hardt	e46ac14118	Update python-package.yml	2022-11-15 12:09:58 -08:00
Jamie Hardt	bf3a5c37a8	Added conftest.py to fix pytest	2022-11-15 20:08:30 +00:00
Jamie Hardt	d3b08e9238	Addressed some lint notes	2022-11-15 20:06:11 +00:00
Jamie Hardt	c0d192e651	Delete test-coverage.sh	2022-11-15 11:47:46 -08:00
Jamie Hardt	d3cc9074c4	Update pythonpublish.yml	2022-11-15 11:27:18 -08:00
Jamie Hardt	87108c7865	Update __init__.py Bump version	2022-11-15 10:28:42 -08:00
Jamie Hardt	04422360f0	Tweaks to quickstart	2022-11-06 14:26:08 -08:00
Jamie Hardt	cd4122ce50	Update README.md	2022-11-06 14:23:52 -08:00