├── .gitattributes
├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── common.py
├── prass.py
├── run-tests.py
├── setup.py
├── subs.py
├── tests
    ├── __init__.py
    ├── cleanup_script.ass
    ├── test_main.py
    ├── test_script.ass
    ├── test_subs.py
    └── test_tools.py
└── tools.py


/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | *.sln    merge=union
 7 | *.csproj merge=union
 8 | *.vbproj merge=union
 9 | *.fsproj merge=union
10 | *.dbproj merge=union
11 | 
12 | # Standard to msysgit
13 | *.doc	 diff=astextplain
14 | *.DOC	 diff=astextplain
15 | *.docx diff=astextplain
16 | *.DOCX diff=astextplain
17 | *.dot  diff=astextplain
18 | *.DOT  diff=astextplain
19 | *.pdf  diff=astextplain
20 | *.PDF	 diff=astextplain
21 | *.rtf	 diff=astextplain
22 | *.RTF	 diff=astextplain
23 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | test
3 | *.pyc
4 | tests/media
5 | dist
6 | build
7 | tests.json
8 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: python
2 | python:
3 |     - "2.7"
4 |     - "3.5"
5 | install:
6 |     - pip install .
7 | script:
8 |     - python run-tests.py
9 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015 Victor Efimov
 2 | 
 3 | Permission is hereby granted, free of charge, to any person
 4 | obtaining a copy of this software and associated documentation
 5 | files (the "Software"), to deal in the Software without
 6 | restriction, including without limitation the rights to use,
 7 | copy, modify, merge, publish, distribute, sublicense, and/or sell
 8 | copies of the Software, and to permit persons to whom the
 9 | Software is furnished to do so, subject to the following
10 | conditions:
11 | 
12 | The above copyright notice and this permission notice shall be
13 | included in all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
17 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## Prass [![Build Status](https://travis-ci.org/tp7/Prass.svg)](https://travis-ci.org/tp7/Prass)
 2 | Console processor for ASS subtitles.
 3 | 
 4 | Feature requests and any kind of feedback are welcome.
 5 | 
 6 | ### Why?
 7 | Imagine you've got a few dozens of subtitle files and you want to apply TPP to each of them, and maybe also restyle one of the files and use the same group of styles for everything else. This script allows you to easily do it from console so you don't have to suffer with Aegisub.
 8 | 
 9 | ### Usage
10 | The main script is called `prass.py` and it provides a few commands for working with subtitles.
11 | ```bash
12 | # to convert subtitles from SRT to ASS
13 | prass convert-srt input.srt -o output.ass
14 | # to copy styles from one ASS script to another
15 | prass copy-styles --from template.ass --to input.ass -o output.ass
16 | # to sort an ASS script
17 | prass sort input.ass --by time -o output.ass
18 | # to run tpp
19 | prass tpp input.ass -s default,alt --lead-in 100 --lead-out 200 --keyframes kfs.txt --fps 23.976 --kf-before-start 150 --kf-after-start 150
20 | # to cleanup a script
21 | prass cleanup --comments --empty-lines --styles input.ass -o output.ass
22 | # to shift start time back by 1 minute and 10 seconds
23 | prass shift --start --by -1:10 input.ass -o output.ass
24 | ```
25 | Some parameters are not mentioned - just run `prass --help` or `prass %command% --help` to see the full docs.
26 | 
27 | ### Pipes
28 | Prass more or less supports pipes and allows you to do fun stuff like
29 | ```bash
30 | prass convert-srt input.srt | prass copy-styles --from template.ass | prass sort --by time | prass tpp --overlap 150 --gap 150 -o out.ass
31 | ```
32 | If you don't provide some file arguments, most commands will use stdin/stdout by default. They will also do this if you provide "-" as file paths.
33 | 
34 | ### Installation
35 | Prass should work on OS X, Linux and Windows without any problems, both on Python 2.7.x and Python 3.x (but py2 is preferable). Right now the only dependency is [Click](http://click.pocoo.org/3/). Assuming you have python and pip, just run:
36 | ```bash
37 | pip install git+https://github.com/tp7/prass
38 | ```
39 | 


--------------------------------------------------------------------------------
/common.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | from click.exceptions import ClickException
 4 | 
 5 | class PrassError(ClickException):
 6 |     pass
 7 | 
 8 | PY2 = sys.version_info[0] == 2
 9 | 
10 | if not PY2:
11 |     py2_unicode_compatible = lambda x: x
12 | 
13 |     itervalues = lambda x: iter(x.values())
14 |     iteritems = lambda x: iter(x.items())
15 |     iterkeys = lambda x: iter(x.keys())
16 |     zip = zip
17 |     map = map
18 | else:
19 |     itervalues = lambda x: x.itervalues()
20 |     iteritems = lambda x: x.iteritems()
21 |     iterkeys = lambda x: x.iterkeys()
22 |     import itertools
23 |     zip = itertools.izip
24 |     map = itertools.imap
25 | 
26 |     def py2_unicode_compatible(cls):
27 |         cls.__unicode__ = cls.__str__
28 |         cls.__str__ = lambda x: x.__unicode__().encode("utf-8")
29 |         return cls
30 | 


--------------------------------------------------------------------------------
/prass.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python2
  2 | import click
  3 | import sys
  4 | from operator import attrgetter
  5 | from common import PrassError, zip, map
  6 | from subs import AssScript
  7 | from tools import Timecodes, parse_keyframes
  8 | 
  9 | CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
 10 | 
 11 | 
 12 | def parse_fps_string(fps_string):
 13 |     if '/' in fps_string:
 14 |         parts = fps_string.split('/')
 15 |         if len(parts) > 2:
 16 |             raise PrassError('Invalid fps value')
 17 |         try:
 18 |             return float(parts[0]) / float(parts[1])
 19 |         except ValueError:
 20 |             raise PrassError('Invalid fps value')
 21 |     else:
 22 |         try:
 23 |             return float(fps_string)
 24 |         except ValueError:
 25 |             raise PrassError('Invalid fps value')
 26 | 
 27 | 
 28 | def parse_shift_string(shift_string):
 29 |     try:
 30 |         if ':' in shift_string:
 31 |             negator = 1
 32 |             if shift_string.startswith('-'):
 33 |                 negator = -1
 34 |                 shift_string = shift_string[1:]
 35 |             parts = list(map(float, shift_string.split(':')))
 36 |             if len(parts) > 3:
 37 |                 raise PrassError("Invalid shift value: '{0}'".format(shift_string))
 38 |             shift_seconds = sum(part * multiplier for part, multiplier in zip(reversed(parts), (1.0, 60.0, 3600.0)))
 39 |             return shift_seconds * 1000 * negator  # convert to ms
 40 |         else:
 41 |             if shift_string.endswith("ms"):
 42 |                 return float(shift_string[:-2])
 43 |             elif shift_string.endswith("s"):
 44 |                 return float(shift_string[:-1]) * 1000
 45 |             else:
 46 |                 return float(shift_string) * 1000
 47 |     except ValueError:
 48 |         raise PrassError("Invalid shift value: '{0}'".format(shift_string))
 49 | 
 50 | 
 51 | def parse_resolution_string(resolution_string):
 52 |     if resolution_string == '720p':
 53 |         return 1280,720
 54 |     if resolution_string == '1080p':
 55 |         return 1920,1080
 56 |     for separator in (':', 'x', ","):
 57 |         if separator in resolution_string:
 58 |             width, _, height = resolution_string.partition(separator)
 59 |             try:
 60 |                 return int(width), int(height)
 61 |             except ValueError:
 62 |                 raise PrassError("Invalid resolution string: '{0}'".format(resolution_string))
 63 |     raise PrassError("Invalid resolution string: '{0}'".format(resolution_string))
 64 | 
 65 | 
 66 | @click.group(context_settings=CONTEXT_SETTINGS)
 67 | def cli():
 68 |     pass
 69 | 
 70 | 
 71 | @cli.command("convert-srt", short_help="convert srt subtitles to ass")
 72 | @click.option("-o", "--output", "output_file", default='-', type=click.File(encoding="utf-8-sig", mode='w'))
 73 | @click.option("--encoding", "encoding", default='utf-8-sig', help="Encoding to use for the input SRT file")
 74 | @click.argument("input_path", type=click.Path(exists=True, dir_okay=False, allow_dash=True))
 75 | def convert_srt(input_path, output_file, encoding):
 76 |     """Convert SRT script to ASS.
 77 | 
 78 |     \b
 79 |     Example:
 80 |     $ prass convert-srt input.srt -o output.ass --encoding cp1251
 81 |     """
 82 |     try:
 83 |         with click.open_file(input_path, encoding=encoding) as input_file:
 84 |             AssScript.from_srt_stream(input_file).to_ass_stream(output_file)
 85 |     except LookupError:
 86 |         raise PrassError("Encoding {0} doesn't exist".format(encoding))
 87 | 
 88 | 
 89 | @cli.command('copy-styles', short_help="copy styles from one ass script to another")
 90 | @click.option("-o", "--output", "output_file", default="-", type=click.File(encoding="utf-8-sig", mode='w'))
 91 | @click.option('--to', 'dst_file', required=True, type=click.File(encoding='utf-8-sig', mode='r'),
 92 |               help="File to copy the styles to")
 93 | @click.option('--from', 'src_file', required=True, type=click.File(encoding='utf-8-sig', mode='r'),
 94 |               help="File to take the styles from")
 95 | @click.option('--clean', default=False, is_flag=True,
 96 |               help="Remove all older styles in the destination file")
 97 | @click.option('--resample/--no-resample', 'resample', default=True,
 98 |               help="Resample style resolution to match output script when possible")
 99 | @click.option('--resolution', 'forced_resolution', default=None, help="Assume resolution of the destination file")
100 | def copy_styles(dst_file, src_file, output_file, clean, resample, forced_resolution):
101 |     """Copy styles from one ASS script to another, write the result as a third script.
102 |     You always have to provide the "from" argument, "to" defaults to stdin and "output" defaults to stdout.
103 | 
104 |     \b
105 |     Simple usage:
106 |     $ prass copy-styles --from template.ass --to unstyled.ass -o styled.ass
107 |     With pipes:
108 |     $ cat unstyled.ass | prass copy-styles --from template.ass | prass cleanup --comments -o out.ass
109 |     """
110 |     src_script = AssScript.from_ass_stream(src_file)
111 |     dst_script = AssScript.from_ass_stream(dst_file)
112 |     if forced_resolution:
113 |         forced_resolution = parse_resolution_string(forced_resolution)
114 | 
115 |     dst_script.append_styles(src_script, clean, resample, forced_resolution)
116 |     dst_script.to_ass_stream(output_file)
117 | 
118 | 
119 | @cli.command('sort', short_help="sort ass script events")
120 | @click.option("-o", "--output", "output_file", default='-', type=click.File(encoding="utf-8-sig", mode='w'), metavar="<path>")
121 | @click.argument("input_file", type=click.File(encoding="utf-8-sig"))
122 | @click.option('--by', 'sort_by', multiple=True, default=['start'], help="Parameter to sort by",
123 |               type=click.Choice(['time', 'start', 'end', 'style', 'actor', 'effect', 'layer']))
124 | @click.option('--desc', 'descending', default=False, is_flag=True, help="Descending order")
125 | def sort_script(input_file, output_file, sort_by, descending):
126 |     """Sort script by one or more parameters.
127 | 
128 |     \b
129 |     Sorting by time:
130 |     $ prass sort input.ass --by time -o output.ass
131 |     Sorting by time and then by layer, both in descending order:
132 |     $ prass sort input.ass --by time --by layer --desc -o output.ass
133 | 
134 |     """
135 |     script = AssScript.from_ass_stream(input_file)
136 |     attrs_map = {
137 |         "start": "start",
138 |         "time": "start",
139 |         "end": "end",
140 |         "style": "style",
141 |         "actor": "actor",
142 |         "effect": "effect",
143 |         "layer": "layer"
144 |     }
145 |     getter = attrgetter(*[attrs_map[x] for x in sort_by])
146 |     script.sort_events(getter, descending)
147 |     script.to_ass_stream(output_file)
148 | 
149 | 
150 | @cli.command('tpp', short_help="timing post-processor")
151 | @click.option("-o", "--output", "output_file", default='-', type=click.File(encoding="utf-8-sig", mode='w'), metavar="<path>")
152 | @click.argument("input_file", type=click.File(encoding="utf-8-sig"))
153 | @click.option("-s", "--style", "styles", multiple=True, metavar="<names>",
154 |               help="Style names to process. All by default. Use comma to separate, or supply it multiple times")
155 | @click.option("--lead-in", "lead_in", default=0, type=int, metavar="<ms>",
156 |               help="Lead-in value in milliseconds")
157 | @click.option("--lead-out", "lead_out", default=0, type=int, metavar="<ms>",
158 |               help="Lead-out value in milliseconds")
159 | @click.option("--overlap", "max_overlap", default=0, type=int, metavar="<ms>",
160 |               help="Maximum overlap for two lines to be made continuous, in milliseconds")
161 | @click.option("--gap", "max_gap", default=0, type=int, metavar="<ms>",
162 |               help="Maximum gap between two lines to be made continuous, in milliseconds")
163 | @click.option("--bias", "adjacent_bias", default=50, type=click.IntRange(0, 100), metavar="<percent>",
164 |               help="How to set the adjoining of lines. "
165 |                    "0 - change start time of the second line, 100 - end time of the first line. "
166 |                    "Values from 0 to 100 allowed.")
167 | @click.option("--keyframes", "keyframes_path", type=click.Path(exists=True, readable=True, dir_okay=False), metavar="<path>",
168 |               help="Path to keyframes file")
169 | @click.option("--timecodes", "timecodes_path", type=click.Path(readable=True, dir_okay=False), metavar="<path>",
170 |               help="Path to timecodes file")
171 | @click.option("--fps", "fps", metavar="<float>",
172 |               help="Fps provided as decimal or proper fraction, in case you don't have timecodes")
173 | @click.option("--kf-before-start", default=0, type=float, metavar="<ms>",
174 |               help="Max distance between a keyframe and event start for it to be snapped, when keyframe is placed before the event")
175 | @click.option("--kf-after-start", default=0, type=float, metavar="<ms>",
176 |               help="Max distance between a keyframe and event start for it to be snapped, when keyframe is placed after the start time")
177 | @click.option("--kf-before-end", default=0, type=float, metavar="<ms>",
178 |               help="Max distance between a keyframe and event end for it to be snapped, when keyframe is placed before the end time")
179 | @click.option("--kf-after-end", default=0, type=float, metavar="<ms>",
180 |               help="Max distance between a keyframe and event end for it to be snapped, when keyframe is placed after the event")
181 | def tpp(input_file, output_file, styles, lead_in, lead_out, max_overlap, max_gap, adjacent_bias,
182 |         keyframes_path, timecodes_path, fps, kf_before_start, kf_after_start, kf_before_end, kf_after_end):
183 |     """Timing post-processor.
184 |     It's a pretty straightforward port from Aegisub so you should be familiar with it.
185 |     You have to specify keyframes and timecodes (either as a CFR value or a timecodes file) if you want keyframe snapping.
186 |     All parameters default to zero so if you don't want something - just don't put it in the command line.
187 | 
188 |     \b
189 |     To add lead-in and lead-out:
190 |     $ prass tpp input.ass --lead-in 50 --lead-out 150 -o output.ass
191 |     To make adjacent lines continuous, with 80% bias to changing end time of the first line:
192 |     $ prass tpp input.ass --overlap 50 --gap 200 --bias 80 -o output.ass
193 |     To snap events to keyframes without a timecodes file:
194 |     $ prass tpp input.ass --keyframes kfs.txt --fps 23.976 --kf-before-end 150 --kf-after-end 150 --kf-before-start 150 --kf-after-start 150 -o output.ass
195 |     """
196 | 
197 |     if fps and timecodes_path:
198 |         raise PrassError('Timecodes file and fps cannot be specified at the same time')
199 |     if fps:
200 |         timecodes = Timecodes.cfr(parse_fps_string(fps))
201 |     elif timecodes_path:
202 |         timecodes = Timecodes.from_file(timecodes_path)
203 |     elif any((kf_before_start, kf_after_start, kf_before_end, kf_after_end)):
204 |         raise PrassError('You have to provide either fps or timecodes file for keyframes processing')
205 |     else:
206 |         timecodes = None
207 | 
208 |     if timecodes and not keyframes_path:
209 |         raise PrassError('You have to specify keyframes file for keyframes processing')
210 | 
211 |     keyframes_list = parse_keyframes(keyframes_path) if keyframes_path else None
212 | 
213 |     actual_styles = []
214 |     for style in styles:
215 |         actual_styles.extend(x.strip() for x in style.split(','))
216 | 
217 |     script = AssScript.from_ass_stream(input_file)
218 |     script.tpp(actual_styles, lead_in, lead_out, max_overlap, max_gap, adjacent_bias,
219 |                keyframes_list, timecodes, kf_before_start, kf_after_start, kf_before_end, kf_after_end)
220 |     script.to_ass_stream(output_file)
221 | 
222 | 
223 | @cli.command("cleanup", short_help="remove useless data from ass scripts")
224 | @click.option("-o", "--output", "output_file", default='-', type=click.File(encoding="utf-8-sig", mode='w'), metavar="<path>")
225 | @click.argument("input_file", type=click.File(encoding="utf-8-sig"))
226 | @click.option("--comments", "drop_comments", default=False, is_flag=True,
227 |               help="Remove commented lines")
228 | @click.option("--empty-lines", "drop_empty_lines", default=False, is_flag=True,
229 |               help="Remove empty lines")
230 | @click.option("--styles", "drop_unused_styles", default=False, is_flag=True,
231 |               help="Remove unused styles")
232 | @click.option("--actors", "drop_actors", default=False, is_flag=True,
233 |               help="Remove actor field")
234 | @click.option("--effects", "drop_effects", default=False, is_flag=True,
235 |               help="Remove effects field")
236 | @click.option("--spacing", "drop_spacing", default=False, is_flag=True,
237 |               help="Removes double spacing and newlines")
238 | @click.option("--sections", "drop_sections", type=click.Choice(["fonts", "graphics", "aegi", "extradata"]), multiple=True,
239 |               help="Remove optional sections from the script")
240 | def cleanup(input_file, output_file, drop_comments, drop_empty_lines, drop_unused_styles,
241 |             drop_actors, drop_effects, drop_spacing, drop_sections):
242 |     """Remove junk data from ASS script
243 | 
244 |     \b
245 |     To remove commented and empty lines plus clear unused styles:
246 |     $ prass cleanup input.ass --comments --empty-lines --styles output.ass
247 |     """
248 |     sections_map = {
249 |         "fonts": "[Fonts]",
250 |         "graphics": "[Graphics]",
251 |         "aegi": "[Aegisub Project Garbage]",
252 |         "extradata": "[Aegisub Extradata]"
253 |     }
254 |     drop_sections = [sections_map[x] for x in drop_sections]
255 | 
256 |     script = AssScript.from_ass_stream(input_file)
257 |     script.cleanup(drop_comments, drop_empty_lines, drop_unused_styles, drop_actors, drop_effects, drop_spacing, drop_sections)
258 |     script.to_ass_stream(output_file)
259 | 
260 | 
261 | @cli.command("shift", short_help="shift start or end times of every event")
262 | @click.option("-o", "--output", "output_file", default='-', type=click.File(encoding="utf-8-sig", mode='w'), metavar="<path>")
263 | @click.argument("input_file", type=click.File(encoding="utf-8-sig"))
264 | @click.option("--by", "shift_by", required=False, default="0", metavar="<time>",
265 |               help="Time to shift. Might be negative. 10.5s, 150ms or 1:12.23 formats are allowed, seconds assumed by default")
266 | @click.option("--start", "shift_start", default=False, is_flag=True, help="Shift only start time")
267 | @click.option("--end", "shift_end", default=False, is_flag=True, help="Shift only end time")
268 | @click.option("--multiplier", "multiplier", default="1", 
269 |               help="Multiplies timings by the value to change speed. Value is a decimal or proper fraction")
270 | def shift(input_file, output_file, shift_by, shift_start, shift_end, multiplier):
271 |     """Shift all lines in a script by defined amount and/or change speed.
272 | 
273 |     \b
274 |     You can use one of the following formats to specify the time for shift:
275 |         - "1.5s" or just "1.5" means 1 second 500 milliseconds
276 |         - "150ms" means 150 milliseconds
277 |         - "1:7:12.55" means 1 hour, 7 minutes, 12 seconds and 550 milliseconds. All parts are optional.
278 |     Every format allows a negative sign before the value, which means "shift back", like "-12s"
279 | 
280 |     \b
281 |     Optionally, specify multiplier to change speed:
282 |         - 1.2 makes subs 20% faster
283 |         - 7/8 makes subs 12.5% slower
284 | 
285 |     \b
286 |     To shift both start end end time by one minute and 15 seconds:
287 |     $ prass shift input.ass --by 1:15 -o output.ass
288 |     To shift only start time by half a second back:
289 |     $ prass shift input.ass --start --by -0.5s -o output.ass
290 |     """
291 |     if not shift_start and not shift_end:
292 |         shift_start = shift_end = True
293 | 
294 |     shift_ms = parse_shift_string(shift_by)
295 |     multiplier = parse_fps_string(multiplier)
296 |     if multiplier<0:
297 |         raise PrassError('Speed multiplier should be a positive number')
298 |     script = AssScript.from_ass_stream(input_file)
299 |     script.shift(shift_ms, shift_start, shift_end, multiplier)
300 |     script.to_ass_stream(output_file)
301 | 
302 | 
303 | if __name__ == '__main__':
304 |     default_map = {}
305 |     if not sys.stdin.isatty():
306 |         for command, arg_name in (("convert-srt", "input_path"), ("copy-styles", "dst_file"),
307 |                                   ("sort", "input_file"), ("tpp", "input_file"), ("cleanup", "input_file"),
308 |                                   ('shift', "input_file")):
309 |             default_map[command] = {arg_name: '-'}
310 | 
311 |     cli(default_map=default_map)
312 | 


--------------------------------------------------------------------------------
/run-tests.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 | import unittest
4 | from tests.test_subs import *
5 | from tests.test_tools import *
6 | from tests.test_main import *
7 | 
8 | unittest.main(verbosity=0)
9 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup
 2 | 
 3 | setup(
 4 |     name='Prass',
 5 |     version='0.1',
 6 |     py_modules=['prass', 'common', 'subs', 'tools'],
 7 |     install_requires=['Click'],
 8 |     entry_points='''
 9 |         [console_scripts]
10 |         prass=prass:cli
11 |     ''',
12 | )
13 | 


--------------------------------------------------------------------------------
/subs.py:
--------------------------------------------------------------------------------
  1 | import codecs
  2 | import os
  3 | import bisect
  4 | import re
  5 | import copy
  6 | import logging
  7 | from collections import OrderedDict
  8 | try:
  9 |     import webcolors
 10 | except:
 11 |     webcolors = None
 12 | 
 13 | from tools import Timecodes
 14 | from common import PrassError, zip, map, itervalues, iterkeys, iteritems, py2_unicode_compatible
 15 | 
 16 | 
 17 | STYLES_SECTION = u"[V4+ Styles]"
 18 | EVENTS_SECTION = u"[Events]"
 19 | SCRIPT_INFO_SECTION = u"[Script Info]"
 20 | 
 21 | 
 22 | def parse_ass_time(string):
 23 |     hours, minutes, seconds, centiseconds = map(int, re.match(r"(\d+):(\d+):(\d+)\.(\d+)", string).groups())
 24 |     return hours * 3600000 + minutes * 60000 + seconds * 1000 + centiseconds * 10
 25 | 
 26 | 
 27 | def parse_srt_time(string):
 28 |     hours, minutes, seconds, milliseconds = map(int, re.match(r"(\d+):(\d+):(\d+)\,(\d+)", string).groups())
 29 |     return hours * 3600000 + minutes * 60000 + seconds * 1000 + milliseconds
 30 | 
 31 | def srt_line_to_ass(line, box=False):
 32 |     line = line.replace('\n', r'\N')
 33 |     if '<' in line:
 34 |         for tag in ['i', 'b', 'u', 's']:
 35 |             line = line.replace('<%s>' % tag, '{\\%s1}' % tag)
 36 |             line = line.replace('</%s>' % tag, '{\\%s0}' % tag)
 37 |         while '<font color="' in line:
 38 |             pre, color, post = re.match(r'(.*)\<font color="(.*?)"\>(.*)', line).groups()
 39 |             if color.startswith('#'):
 40 |                 r, g, b = color[1:3], color[3:5], color[5:]
 41 |             elif webcolors:
 42 |                 r, g, b = map(lambda x: "%02X" % x, webcolors.name_to_rgb(color))
 43 |             else:
 44 |                 logging.warning('Can\'t parse color "%s", please install webcolors module.' % color)
 45 |                 break
 46 |             line = pre + '{\c&H%s%s%s&}' % (b, g, r) + post
 47 |         line = line.replace('</font>', '{\c&HFFFFFF&}')
 48 |     return line
 49 | 
 50 | def format_time(ms):
 51 |     cs = int(ms / 10.0)
 52 |     return u'{0}:{1:02d}:{2:02d}.{3:02d}'.format(
 53 |             int(cs // 360000),
 54 |             int((cs // 6000) % 60),
 55 |             int((cs // 100) % 60),
 56 |             int(cs % 100))
 57 | 
 58 | 
 59 | class AssStyle(object):
 60 |     def __init__(self, name, definition):
 61 |         self.name = name
 62 |         self.definition = definition
 63 | 
 64 |     @classmethod
 65 |     def from_string(cls, text):
 66 |         name, definition = text.split(',', 1)
 67 |         return cls(name=name.strip(), definition=definition.strip())
 68 | 
 69 |     def resample(self, from_width, from_height, to_width, to_height, scale_border_and_shadow=True):
 70 |         scale_height = to_height / float(from_height)
 71 |         scale_width = to_width / float(from_width)
 72 |         old_ar = from_width / float(from_height)
 73 |         new_ar = to_width / float(to_height)
 74 |         horizontal_stretch = 1.0
 75 |         if abs(old_ar - new_ar) / new_ar > 0.01:
 76 |             horizontal_stretch = new_ar / old_ar
 77 | 
 78 |         parts = self.definition.split(",")
 79 |         parts[1] = "%i" % (round(int(parts[1]) * scale_height))  # font size
 80 |         parts[10] = "%g" % (float(parts[10]) * horizontal_stretch)  # scale x
 81 |         parts[12] = "%g" % (float(parts[12]) * scale_width)  # spacing
 82 |         if scale_border_and_shadow:
 83 |             parts[15] = "%g" % (float(parts[15]) * scale_height)  # outline
 84 |             parts[16] = "%g" % (float(parts[16]) * scale_height)  # shadow
 85 |         parts[18] = "%i" % (round(float(parts[18]) * scale_width))  # margin l
 86 |         parts[19] = "%i" % (round(float(parts[19]) * scale_width))  # margin r
 87 |         parts[20] = "%i" % (round(float(parts[20]) * scale_height))  # margin v
 88 | 
 89 |         self.definition = u",".join(parts)
 90 | 
 91 | 
 92 | @py2_unicode_compatible
 93 | class AssEvent(object):
 94 |     __slots__ = (
 95 |         "kind",
 96 |         "layer",
 97 |         "start",
 98 |         "end",
 99 |         "style",
100 |         "actor",
101 |         "margin_left",
102 |         "margin_right",
103 |         "margin_vertical",
104 |         "effect",
105 |         "text"
106 |     )
107 | 
108 |     def __init__(self, start, end, text, kind='Dialogue', layer=0, style='Default', actor='',
109 |                  margin_left=0, margin_right=0, margin_vertical=0, effect=''):
110 |         self.kind = kind
111 |         self.layer = layer
112 |         self.start = start
113 |         self.end = end
114 |         self.style = style
115 |         self.actor = actor
116 |         self.margin_left = margin_left
117 |         self.margin_right = margin_right
118 |         self.margin_vertical = margin_vertical
119 |         self.effect = effect
120 |         self.text = text
121 | 
122 |     @classmethod
123 |     def from_text(cls, text):
124 |         kind, _, rest = text.partition(u":")
125 |         split = [x.strip() for x in rest.split(',', 9)]
126 |         return cls(
127 |             kind=kind,
128 |             layer=int(split[0]),
129 |             start=parse_ass_time(split[1]),
130 |             end=parse_ass_time(split[2]),
131 |             style=split[3],
132 |             actor=split[4],
133 |             margin_left=split[5],
134 |             margin_right=split[6],
135 |             margin_vertical=split[7],
136 |             effect=split[8],
137 |             text=split[9]
138 |         )
139 | 
140 |     def __str__(self):
141 |         return u'{0}: {1},{2},{3},{4},{5},{6},{7},{8},{9},{10}'.format(self.kind, self.layer,
142 |                                                                        format_time(self.start),
143 |                                                                        format_time(self.end),
144 |                                                                        self.style, self.actor,
145 |                                                                        self.margin_left, self.margin_right,
146 |                                                                        self.margin_vertical, self.effect,
147 |                                                                        self.text)
148 | 
149 |     @property
150 |     def is_comment(self):
151 |         return self.kind.lower() == u'comment'
152 | 
153 |     def collides_with(self, other):
154 |         if self.start < other.start:
155 |             return self.end > other.start
156 |         return self.start < other.end
157 | 
158 | 
159 | class StylesSection(object):
160 |     def __init__(self):
161 |         self.styles = OrderedDict()
162 | 
163 |     def parse_line(self, text):
164 |         if text.startswith(u'Format:'):
165 |             return
166 |         style = AssStyle.from_string(text.partition(u":")[2])
167 |         self.styles[style.name] = style
168 | 
169 |     def format_section(self):
170 |         lines = [u'Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding']
171 |         lines.extend(u'Style: {0},{1}'.format(style.name, style.definition) for style in itervalues(self.styles))
172 |         return lines
173 | 
174 | 
175 | class EventsSection(object):
176 |     def __init__(self):
177 |         self.events = []
178 | 
179 |     def parse_line(self, text):
180 |         if text.startswith(u'Format:'):
181 |             return
182 |         self.events.append(AssEvent.from_text(text))
183 | 
184 |     def format_section(self):
185 |         lines = [u'Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text']
186 |         lines.extend(u"%s" % x for x in self.events)
187 |         return lines
188 | 
189 | 
190 | class ScriptInfoSection(object):
191 |     class PropertyLine(object):
192 |         def __init__(self, name, value):
193 |             self.name = name
194 |             self.value = value
195 | 
196 |         @classmethod
197 |         def from_string(cls, string_value):
198 |             if string_value.startswith(';'):
199 |                 return cls(string_value, None)
200 |             else:
201 |                 name, _, value = string_value.partition(':')
202 |                 return cls(name, value.strip())
203 | 
204 |         def to_string(self):
205 |             if self.value is None:
206 |                 return self.name
207 |             return u"{0}: {1}".format(self.name, self.value)
208 | 
209 |     def __init__(self):
210 |         self._lines_dict = OrderedDict()
211 | 
212 |     def parse_line(self, text):
213 |         prop = self.PropertyLine.from_string(text)
214 |         self._lines_dict[prop.name] = prop
215 | 
216 |     def format_section(self):
217 |         return [x.to_string() for x in itervalues(self._lines_dict)]
218 | 
219 |     def get_property(self, name):
220 |         if name not in self._lines_dict:
221 |             raise KeyError("Property {0} not found".format(name))
222 |         return self._lines_dict[name].value
223 | 
224 |     def set_property(self, name, value):
225 |         if name not in self._lines_dict:
226 |             self._lines_dict[name] = self.PropertyLine(name, str(value))
227 |         else:
228 |             self._lines_dict[name].value = str(value)
229 | 
230 |     def get_resolution(self):
231 |         try:
232 |             width = int(self.get_property("PlayResX"))
233 |             height = int(self.get_property("PlayResY"))
234 |             return width, height
235 |         except KeyError:
236 |             return None, None
237 | 
238 |     def set_resolution(self, width, height):
239 |         self.set_property("PlayResX", width)
240 |         self.set_property("PlayResY", height)
241 | 
242 |     def get_scaled_border_property(self):
243 |         try:
244 |             return self.get_property("ScaledBorderAndShadow")=="yes"
245 |         except KeyError:
246 |             return True
247 | 
248 | 
249 | class GenericSection(object):
250 |     def __init__(self):
251 |         self.lines = []
252 | 
253 |     def parse_line(self, line):
254 |         self.lines.append(line)
255 | 
256 |     def format_section(self):
257 |         return self.lines
258 | 
259 | 
260 | class AttachmentSection(GenericSection):
261 |     def parse_line(self, line):
262 |         if not line:
263 |             return False
264 |         self.lines.append(line)
265 | 
266 |         # as usual, copied from aegisub
267 |         is_valid = 0 < len(line) <= 80 #and all(33 <= ord(x) < 97 for x in line)
268 |         is_filename = line.startswith("fontname: ") or line.startswith("filename: ")
269 |         return is_valid or is_filename
270 | 
271 | 
272 | class AssScript(object):
273 |     def __init__(self, sections_list):
274 |         super(AssScript, self).__init__()
275 |         self._sections_list = sections_list
276 | 
277 |     @property
278 |     def _events(self):
279 |         return self._find_section(EVENTS_SECTION).events
280 | 
281 |     @_events.setter
282 |     def _events(self, value):
283 |         self._find_section(EVENTS_SECTION).events = value
284 | 
285 |     @property
286 |     def _styles(self):
287 |         return self._find_section(STYLES_SECTION).styles
288 | 
289 |     def _find_section(self, name):
290 |         return next((section for section_name, section in self._sections_list if section_name == name), None)
291 | 
292 |     @classmethod
293 |     def from_ass_stream(cls, file_object):
294 |         sections = []
295 |         current_section = None
296 |         force_last_section = False
297 |         for idx, line in enumerate(file_object):
298 |             line = line.strip()
299 |             # required because a line might be both a part of an attachment and a valid header
300 |             if force_last_section:
301 |                 try:
302 |                     force_last_section = current_section.parse_line(line)
303 |                     continue
304 |                 except Exception as e:
305 |                     raise PrassError(u"That's some invalid ASS script: {0}".format(e.message))
306 | 
307 |             if not line:
308 |                 continue
309 |             low = line.lower()
310 |             if low == u'[v4+ styles]':
311 |                 current_section = StylesSection()
312 |                 sections.append((line, current_section))
313 |             elif low == u'[events]':
314 |                 current_section = EventsSection()
315 |                 sections.append((line, current_section))
316 |             elif low == u'[script info]':
317 |                 current_section = ScriptInfoSection()
318 |                 sections.append((line, current_section))
319 |             elif low == u'[graphics]' or low == u'[fonts]':
320 |                 current_section = AttachmentSection()
321 |                 sections.append((line, current_section))
322 |             elif re.match(r'^\s*\[.+?\]\s*$', low):
323 |                 current_section = GenericSection()
324 |                 sections.append((line, current_section))
325 |             elif not current_section:
326 |                 raise PrassError(u"That's some invalid ASS script (no parse function at line {0})".format(idx))
327 |             else:
328 |                 try:
329 |                     force_last_section = current_section.parse_line(line)
330 |                 except Exception as e:
331 |                     raise PrassError(u"That's some invalid ASS script: {0}".format(e.message))
332 |         return cls(sections)
333 | 
334 |     @classmethod
335 |     def from_ass_file(cls, path):
336 |         try:
337 |             with codecs.open(path, encoding='utf-8-sig') as script:
338 |                 return cls.from_ass_stream(script)
339 |         except IOError:
340 |             raise PrassError("Script {0} not found".format(path))
341 | 
342 |     @classmethod
343 |     def from_srt_stream(cls, file_object):
344 |         styles_section = StylesSection()
345 |         events_section = EventsSection()
346 | 
347 |         for srt_event in file_object.read().replace('\r\n', '\n').split('\n\n'):
348 |             if not srt_event:
349 |                 continue
350 |             lines = srt_event.split('\n', 2)
351 |             times = lines[1].split('-->')
352 |             if 'X' in times[1] or 'Y' in times[1]:
353 |                 times[1], box = times[1].strip().split(' ', 1)
354 |             else:
355 |                 box = False
356 |             text=srt_line_to_ass(lines[2])
357 |             events_section.events.append(AssEvent(
358 |                 start=parse_srt_time(times[0].rstrip()),
359 |                 end=parse_srt_time(times[1].lstrip()),
360 |                 text=text
361 |             ))
362 |         styles_section.styles[u'Default'] = AssStyle(u'Default', 'Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,2,2,10,10,10,1')
363 |         script_info = ScriptInfoSection()
364 |         script_info.parse_line(u'; Script converted by Prass')
365 |         script_info.set_resolution(384, 288)
366 |         return cls([
367 |             (SCRIPT_INFO_SECTION, script_info),
368 |             (STYLES_SECTION, styles_section),
369 |             (EVENTS_SECTION, events_section),
370 |         ])
371 | 
372 |     def to_ass_stream(self, file_object):
373 |         lines = []
374 |         for name, section in self._sections_list:
375 |             lines.append(name)
376 |             lines.extend(section.format_section())
377 |             lines.append(u"")
378 | 
379 |         file_object.write("\n".join(lines))
380 | 
381 |     def to_ass_file(self, path):
382 |         with codecs.open(path, encoding='utf-8-sig', mode='w') as script:
383 |             self.to_ass_stream(script)
384 |     
385 |     def scale_to_reference(self, reference, forced_resolution=None):
386 |         src_width, src_height = self._find_section(SCRIPT_INFO_SECTION).get_resolution()
387 |         scale_border_and_shadow = self._find_section(SCRIPT_INFO_SECTION).get_scaled_border_property()
388 |         if forced_resolution:
389 |             dst_width, dst_height = forced_resolution
390 |         else:
391 |             dst_width, dst_height = reference._find_section(SCRIPT_INFO_SECTION).get_resolution()
392 |         if all((src_width, src_height, dst_width, dst_height)):
393 |             for style in itervalues(self._styles):
394 |                 style.resample(src_width, src_height, dst_width, dst_height, scale_border_and_shadow)
395 |             self._find_section(SCRIPT_INFO_SECTION).set_resolution(dst_width, dst_height)
396 |         else:
397 |             logging.info("Couldn't determine resolution, resampling disabled")
398 |     
399 |     def append_styles(self, other_script, clean, resample, forced_resolution=None):
400 |         if clean:
401 |             self._styles.clear()
402 | 
403 |         if resample:
404 |             other_script_resampled = copy.deepcopy(other_script)
405 |             other_script_resampled.scale_to_reference(self, forced_resolution)
406 |             if forced_resolution:
407 |                 self.scale_to_reference(self, forced_resolution)
408 |         else:
409 |             other_script_resampled = other_script
410 |         for style in itervalues(other_script_resampled._styles):
411 |             self._styles[style.name] = copy.deepcopy(style)
412 | 
413 |     def sort_events(self, key, descending):
414 |         self._events.sort(key=key, reverse=descending)
415 | 
416 |     def tpp(self, styles, lead_in, lead_out, max_overlap, max_gap, adjacent_bias,
417 |             keyframes_list, timecodes, kf_before_start, kf_after_start, kf_before_end, kf_after_end):
418 | 
419 |         def get_closest_kf(frame, keyframes):
420 |             idx = bisect.bisect_left(keyframes, frame)
421 |             if idx == len(keyframes):
422 |                 return keyframes[-1]
423 |             if idx == 0 or keyframes[idx] - frame < frame - (keyframes[idx-1]):
424 |                 return keyframes[idx]
425 |             return keyframes[idx-1]
426 | 
427 |         events_iter = (e for e in self._events if not e.is_comment)
428 |         if styles:
429 |             styles = set(s.lower() for s in styles)
430 |             events_iter = (e for e in events_iter if e.style.lower() in styles)
431 | 
432 |         events_list = sorted(events_iter, key=lambda x: x.start)
433 |         broken = next((e for e in events_list if e.start > e.end), None)
434 |         if broken:
435 |             raise PrassError("One of the lines in the file ({0}) has negative duration. Aborting.".format(broken))
436 | 
437 |         if lead_in:
438 |             sorted_by_end = sorted(events_list, key=lambda x: x.end)
439 |             for idx, event in enumerate(sorted_by_end):
440 |                 initial = max(event.start - lead_in, 0)
441 |                 for other in reversed(sorted_by_end[:idx]):
442 |                     if other.end <= initial:
443 |                         break
444 |                     if not event.collides_with(other):
445 |                         initial = max(initial, other.end)
446 |                 event.start = initial
447 | 
448 |         if lead_out:
449 |             for idx, event in enumerate(events_list):
450 |                 initial = event.end + lead_out
451 |                 for other in events_list[idx:]:
452 |                     if other.start > initial:
453 |                         break
454 |                     if not event.collides_with(other):
455 |                         initial = min(initial, other.start)
456 |                 event.end = initial
457 | 
458 |         if max_overlap or max_gap:
459 |             bias = adjacent_bias / 100.0
460 | 
461 |             for previous, current in zip(events_list, events_list[1:]):
462 |                 distance = current.start - previous.end
463 |                 if (distance < 0 and -distance <= max_overlap) or (distance > 0 and distance <= max_gap):
464 |                     new_time = previous.end + distance * bias
465 |                     current.start = new_time
466 |                     previous.end = new_time
467 | 
468 |         if kf_before_start or kf_after_start or kf_before_end or kf_after_end:
469 |             for event in events_list:
470 |                 start_frame = timecodes.get_frame_number(event.start, timecodes.TIMESTAMP_START)
471 |                 end_frame = timecodes.get_frame_number(event.end, timecodes.TIMESTAMP_END)
472 | 
473 |                 closest_frame = get_closest_kf(start_frame, keyframes_list)
474 |                 closest_time = timecodes.get_frame_time(closest_frame, timecodes.TIMESTAMP_START)
475 | 
476 |                 if (end_frame > closest_frame >= start_frame and closest_time - event.start <= kf_after_start) or \
477 |                         (closest_frame <= start_frame and event.start - closest_time <= kf_before_start):
478 |                     event.start = max(0, closest_time)
479 | 
480 |                 closest_frame = get_closest_kf(end_frame, keyframes_list) - 1
481 |                 closest_time = timecodes.get_frame_time(closest_frame, timecodes.TIMESTAMP_END)
482 |                 if (start_frame < closest_frame <= end_frame and event.end - closest_time <= kf_before_end) or \
483 |                         (closest_frame >= end_frame and closest_time - event.end <= kf_after_end):
484 |                     event.end = closest_time
485 | 
486 |     def cleanup(self, drop_comments, drop_empty_lines, drop_unused_styles, drop_actors, drop_effects, drop_spacing, drop_sections):
487 |         if drop_comments:
488 |             self._events = [e for e in self._events if not e.is_comment]
489 | 
490 |         if drop_empty_lines:
491 |             self._events = [e for e in self._events if e.text]
492 | 
493 |         if drop_unused_styles:
494 |             used_styles = set()
495 | 
496 |             for event in self._events:
497 |                 used_styles.add(event.style)
498 |                 for override_block in re.findall(r"{([^{}]*\\r[^{}]*)}", event.text):
499 |                     for style in re.findall(r"\\r([^}\\]+)", override_block):
500 |                         used_styles.add(style)
501 | 
502 |             for style_name in list(iterkeys(self._styles)):
503 |                 if style_name not in used_styles:
504 |                     del self._styles[style_name]
505 | 
506 |         if drop_actors:
507 |             for event in self._events:
508 |                 event.actor = ''
509 | 
510 |         if drop_effects:
511 |             for event in self._events:
512 |                 event.effect = ''
513 | 
514 |         if drop_spacing:
515 |             for event in self._events:
516 |                 event.text = re.sub(r"(\s|\\N|\\n)+", " ", event.text)
517 | 
518 |         if drop_sections:
519 |             self._sections_list = [x for x in self._sections_list if x[0] not in set(drop_sections)]
520 | 
521 |     def shift(self, shift, shift_start, shift_end, multiplier):
522 |         for event in self._events:
523 |             if shift_start:
524 |                 event.start = max(event.start + shift, 0)
525 |             if shift_end:
526 |                 event.end = max(event.end + shift, 0)
527 |             if multiplier != 1:
528 |                 event.start *= multiplier
529 |                 event.end *= multiplier
530 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | 


--------------------------------------------------------------------------------
/tests/cleanup_script.ass:
--------------------------------------------------------------------------------
 1 | [Script Info]
 2 | ; Script generated by Aegisub r8792
 3 | ; http://www.aegisub.org/
 4 | Title: HorribleSubs
 5 | ScriptType: v4.00+
 6 | WrapStyle: 0
 7 | PlayResX: 848
 8 | PlayResY: 480
 9 | ScaledBorderAndShadow: yes
10 | 
11 | [Aegisub Project Garbage]
12 | Active Line: 4
13 | 
14 | [V4+ Styles]
15 | Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
16 | Style: Main,Open Sans Semibold,36,&H00FFFFFF,&H000000FF,&H00020713,&H00000000,-1,0,0,0,100,100,0,0,1,1.7,0,2,0,0,28,0
17 | Style: Internal,Open Sans Semibold,36,&H00FFFFFF,&H000000FF,&H00020713,&H00000000,-1,-1,0,0,100,100,0,0,1,1.7,0,2,0,0,28,0
18 | 
19 | [Graphics]
20 | filename: invalid.jpeg
21 | `^D`Y!!13E:*2A!"!1!"8A&?!!$`Y1-W28BJ:A!!45U!+A!!!!A!#A%/!!)!!!!A!!!!BA%0!!)!!!!&
22 | !!!!JA%1!!)!!!!'!!!!L!%3!!-!!!!"!!%!
23 | 
24 | [Events]
25 | Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
26 | Dialogue: 0,0:00:00.91,0:00:03.44,Main,,0,0,0,,Sorry for making you come along, Shin-chan.
27 | Dialogue: 0,0:00:03.44,0:00:04.46,Main,,0,0,0,,Don't be.
28 | Dialogue: 0,0:00:04.46,0:00:07.27,Main,,0,0,0,,But are you sure you should've bought so much?
29 | Dialogue: 0,0:00:07.60,0:00:09.61,Main,,0,0,0,,They're all clothes to wear at the club,
30 | Dialogue: 0,0:00:09.61,0:00:11.40,Main,,0,0,0,,so they'll be expensed.
31 | Dialogue: 0,0:00:11.65,0:00:13.02,Main,,0,0,0,,Oh...
32 | Dialogue: 0,0:00:13.02,0:00:15.91,Main,,0,0,0,,Meanwhile, all I wear now is this {\b1\rInternal}twin-striped kimono.
33 | Dialogue: 0,0:00:16.42,0:00:17.92,Main,,0,0,0,,I don't leave much of an impression,
34 | Dialogue: 0,0:00:17.92,0:00:20.82,Main,,0,0,0,,so I figure I'll be easier to remember if I always wear the same thing.
35 | 
36 | [Graphics]
37 | filename: invalid.jpeg
38 | `^D`Y!!13E:*2A!"!1!"8A&?!!$`Y1-W28BJ:A!!45U!+A!!!!A!#A%/!!)!!!!A!!!!BA%0!!)!!!!&
39 | !!!!JA%1!!)!!!!'!!!!L!%3!!-!!!!"!!%!
40 | 


--------------------------------------------------------------------------------
/tests/test_main.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | import unittest
 3 | 
 4 | import prass
 5 | import common
 6 | 
 7 | 
 8 | class TestFpsParsing(unittest.TestCase):
 9 |     def test_number(self):
10 |         self.assertEqual(23.976, prass.parse_fps_string("23.976"))
11 |         self.assertEqual(24, prass.parse_fps_string("24"))
12 | 
13 |     def test_division(self):
14 |         self.assertAlmostEqual(23.976, prass.parse_fps_string("24000/1001"), places=3)
15 |         self.assertAlmostEqual(29.970, prass.parse_fps_string("30000/1001"), places=3)
16 | 
17 |     def test_invalid(self):
18 |         self.assertRaises(common.PrassError, lambda: prass.parse_fps_string("24000/1001/1"))
19 |         self.assertRaises(common.PrassError, lambda: prass.parse_fps_string("not a number"))
20 | 
21 | 
22 | class TestShiftParsing(unittest.TestCase):
23 |     def test_number(self):
24 |         self.assertAlmostEqual(-1000, prass.parse_shift_string("-1"))
25 |         self.assertAlmostEqual(1500, prass.parse_shift_string("1.5"))
26 |         self.assertAlmostEqual(12, prass.parse_shift_string("12ms"))
27 |         self.assertAlmostEqual(2500, prass.parse_shift_string("2.5s"))
28 | 
29 |     def test_timestamp(self):
30 |         self.assertAlmostEqual(61000, prass.parse_shift_string("1:1"))
31 |         self.assertAlmostEqual(61530, prass.parse_shift_string("1:1.53"))
32 |         self.assertAlmostEqual(61530, prass.parse_shift_string("1:1.53"))
33 |         self.assertAlmostEqual(-61530, prass.parse_shift_string("-1:1.53"))
34 |         self.assertAlmostEqual((12 * 3600 + 15 * 60) * 1000 + 23128, prass.parse_shift_string("12:15:23.128"))
35 | 
36 |     def test_invalid(self):
37 |         self.assertRaises(common.PrassError, lambda: prass.parse_shift_string("1:1:1:1"))
38 |         self.assertRaises(common.PrassError, lambda: prass.parse_shift_string("123seconds"))
39 |         self.assertRaises(common.PrassError, lambda: prass.parse_shift_string("not a number"))
40 | 
41 | 
42 | class TestResolutionParsing(unittest.TestCase):
43 |     def test_templates(self):
44 |         self.assertEqual((1280, 720), prass.parse_resolution_string("720p"))
45 |         self.assertEqual((1920, 1080), prass.parse_resolution_string("1080p"))
46 | 
47 |     def test_full_definition(self):
48 |         self.assertEqual((1280,720), prass.parse_resolution_string("1280:720"))
49 |         self.assertEqual((848,480), prass.parse_resolution_string("848x480"))
50 | 
51 |     def test_invalid(self):
52 |         self.assertRaises(common.PrassError, lambda: prass.parse_resolution_string("720"))
53 |         self.assertRaises(common.PrassError, lambda: prass.parse_resolution_string("1920.1080"))
54 |         self.assertRaises(common.PrassError, lambda: prass.parse_resolution_string("1963p"))
55 |         self.assertRaises(common.PrassError, lambda: prass.parse_resolution_string("not a number"))
56 | 


--------------------------------------------------------------------------------
/tests/test_script.ass:
--------------------------------------------------------------------------------
 1 | [Script Info]
 2 | ; Script generated by Aegisub r8792
 3 | ; http://www.aegisub.org/
 4 | Title: HorribleSubs
 5 | ScriptType: v4.00+
 6 | WrapStyle: 0
 7 | PlayResX: 848
 8 | PlayResY: 480
 9 | ScaledBorderAndShadow: yes
10 | 
11 | [Aegisub Project Garbage]
12 | Active Line: 4
13 | 
14 | [V4+ Styles]
15 | Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
16 | Style: Default,Open Sans Semibold,36,&H00FFFFFF,&H000000FF,&H00020713,&H00000000,-1,0,0,0,100,100,0,0,1,1.7,0,2,0,0,28,1
17 | Style: Main,Open Sans Semibold,36,&H00FFFFFF,&H000000FF,&H00020713,&H00000000,-1,0,0,0,100,100,0,0,1,1.7,0,2,0,0,28,0
18 | Style: Internal,Open Sans Semibold,36,&H00FFFFFF,&H000000FF,&H00020713,&H00000000,-1,-1,0,0,100,100,0,0,1,1.7,0,2,0,0,28,0
19 | Style: Flashback,Open Sans Semibold,36,&H00FFFFFF,&H000000FF,&H004D0701,&H00000000,0,0,0,0,100,100,0,0,1,2,1,2,13,13,20,0
20 | Style: Ep Title,Open Sans Semibold,38,&H0000FFFF,&H000000FF,&H00000000,&H00000000,-1,0,0,0,100,100,0,0,1,2,1,8,40,40,20,0
21 | 
22 | [Graphics]
23 | filename: invalid.jpeg
24 | `^D`Y!!13E:*2A!"!1!"8A&?!!$`Y1-W28BJ:A!!45U!+A!!!!A!#A%/!!)!!!!A!!!!BA%0!!)!!!!&
25 | !!!!JA%1!!)!!!!'!!!!L!%3!!-!!!!"!!%!
26 | 
27 | [Fonts]
28 | filename: invalid.tff
29 | `^D`Y!!13E:*2A!"!1!"8A&?!!$`Y1-W28BJ:A!!45U!+A!!!!A!#A%/!!)!!!!A!!!!BA%0!!)!!!!&
30 | !!!!JA%1!!)!!!!'!!!!L!%3!!-!!!!"!!%!
31 | 
32 | [Events]
33 | Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
34 | Dialogue: 0,0:00:00.91,0:00:03.44,Main,Tae,0,0,0,,Sorry for making you  \N\N   come along, Shin-chan.
35 | Dialogue: 0,0:00:03.44,0:00:04.46,Main,Shin,0,0,0,,Don't be.
36 | Dialogue: 0,0:00:04.46,0:00:07.27,Main,Shin,0,0,0,,But are you sure you \Nshould've bought so much?
37 | Dialogue: 0,0:00:07.60,0:00:07.60,Main,Tae,0,0,0,,
38 | Dialogue: 0,0:00:07.60,0:00:09.61,Main,Tae,0,0,0,gradient,They're all clothes to wear at the club,
39 | Dialogue: 0,0:00:09.61,0:00:11.40,Main,Tae,0,0,0,,so they'll be expensed.
40 | Comment: 0,0:00:11.65,0:00:13.02,Main,Shin,0,0,0,,Commended line
41 | Dialogue: 0,0:00:11.65,0:00:13.02,Main,Shin,0,0,0,,Oh...
42 | Dialogue: 0,0:00:13.02,0:00:15.91,Main,Shin,0,0,0,,Meanwhile, all I wear now \Nis this {\b1\rInternal}twin-striped kimono.
43 | Dialogue: 0,0:00:16.42,0:00:17.92,Main,Shin,0,0,0,,I don't leave much of an impression,
44 | Dialogue: 0,0:00:17.92,0:00:20.82,Main,Shin,0,0,0,,so I figure I'll be easier  to remember\Nif I always wear the same thing.
45 | 
46 | [Graphics]
47 | filename: invalid.jpeg
48 | `^D`Y!!13E:*2A!"!1!"8A&?!!$`Y1-W28BJ:A!!45U!+A!!!!A!#A%/!!)!!!!A!!!!BA%0!!)!!!!&
49 | !!!!JA%1!!)!!!!'!!!!L!%3!!-!!!!"!!%!
50 | 


--------------------------------------------------------------------------------
/tests/test_subs.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | import unittest
  3 | import os
  4 | import codecs
  5 | try:
  6 |     from StringIO import StringIO
  7 | except ImportError:
  8 |     from io import StringIO
  9 | 
 10 | import subs
 11 | 
 12 | 
 13 | def get_script_path(name):
 14 |     script_dir = os.path.dirname(os.path.realpath(__file__))
 15 |     return os.path.join(script_dir, name)
 16 | 
 17 | 
 18 | def script_to_string(ass_script):
 19 |     buffer = StringIO()
 20 |     ass_script.to_ass_stream(buffer)
 21 |     return buffer.getvalue()
 22 | 
 23 | 
 24 | def load_script(name):
 25 |     with codecs.open(get_script_path(name), encoding="utf-8-sig") as input_file:
 26 |         script = input_file.read()
 27 |         # Windows is weid so you need to use \n internally
 28 |         return script.replace("\r\n", "\n")
 29 |         
 30 | 
 31 | 
 32 | class TestSubs(unittest.TestCase):
 33 |     maxDiff = None
 34 | 
 35 |     def test_ass_time_parsing(self):
 36 |         self.assertEqual(150, subs.parse_ass_time("00:00:00.15"))
 37 |         self.assertEqual(12150, subs.parse_ass_time("00:00:12.15"))
 38 |         self.assertEqual(132150, subs.parse_ass_time("00:02:12.15"))
 39 | 
 40 |     def test_srt_time_parsing(self):
 41 |         self.assertEqual(132150, subs.parse_srt_time("00:02:12,150"))
 42 | 
 43 |     def test_srt_line_parsing(self):
 44 |         self.assertEqual(subs.srt_line_to_ass('<u>underlined</u>\n 0<b>1<i>2<s> many </i>3</s>4</b>5'), 
 45 |                         '{\\u1}underlined{\\u0}\\N 0{\\b1}1{\\i1}2{\\s1} many {\\i0}3{\\s0}4{\\b0}5')
 46 |         self.assertEqual(subs.srt_line_to_ass('<b>bold</b>, <i>italic</i>, <s>strikeout</s>'), 
 47 |                         '{\\b1}bold{\\b0}, {\\i1}italic{\\i0}, {\\s1}strikeout{\\s0}')
 48 |         self.assertEqual(subs.srt_line_to_ass('<font color="#FF0000">text</font>'), 
 49 |                         '{\\c&H0000FF&}text{\\c&HFFFFFF&}')
 50 | 
 51 |     def test_cleanup(self):
 52 |         # this test also ensures that we leave two [Graphics] sections in their proper positions
 53 |         ass_script = subs.AssScript.from_ass_file(get_script_path("test_script.ass"))
 54 |         ass_script.cleanup(drop_actors=True, drop_comments=True, drop_effects=True,
 55 |                            drop_empty_lines=True, drop_unused_styles=True, drop_spacing=True, drop_sections=["[Fonts]"])
 56 | 
 57 |         self.assertEqual(load_script("cleanup_script.ass"), script_to_string(ass_script))
 58 | 
 59 |     def test_noop(self):
 60 |         ass_script = subs.AssScript.from_ass_file(get_script_path("test_script.ass"))
 61 |         self.assertEqual(load_script("test_script.ass"), script_to_string(ass_script))
 62 | 
 63 | 
 64 | class TestStyles(unittest.TestCase):
 65 |     def test_resample(self):
 66 |         source = subs.AssStyle.from_string(u"Default,Arial,36,&H00FFFFFF,&H000000FF,&H00020713,&H00000000,-1,0,0,0,100,100,0,0,1,1.7,0,2,0,0,28,1")
 67 |         source.resample(from_width=848, from_height=480, to_width=1920, to_height=1080)
 68 |         self.assertEqual(source.definition, u"Arial,81,&H00FFFFFF,&H000000FF,&H00020713,&H00000000,-1,0,0,0,100,100,0,0,1,3.825,0,2,0,0,63,1")
 69 | 
 70 | 
 71 | class TestScriptInfoSection(unittest.TestCase):
 72 |     def test_comments(self):
 73 |         section = subs.ScriptInfoSection()
 74 |         section.parse_line("; random comment")
 75 |         section.parse_line("; another comment")
 76 |         self.assertEqual(["; random comment", "; another comment"], section.format_section())
 77 | 
 78 |     def test_order(self):
 79 |         section = subs.ScriptInfoSection()
 80 |         section.parse_line("; random")
 81 |         section.parse_line("Property: 2")
 82 |         section.parse_line("; comment")
 83 |         section.parse_line("Another: property")
 84 |         self.assertEqual(["; random", "Property: 2", "; comment", "Another: property"],
 85 |                          section.format_section())
 86 | 
 87 |     def test_resolution(self):
 88 |         section = subs.ScriptInfoSection()
 89 |         self.assertEqual((None, None), section.get_resolution())
 90 | 
 91 |         section.parse_line("PlayResY: 480")
 92 |         section.parse_line("PlayResX: 848")
 93 |         self.assertEqual((848, 480), section.get_resolution())
 94 | 
 95 |         section.set_resolution(1920, 1080)
 96 |         self.assertEqual(["PlayResY: 1080", "PlayResX: 1920"], section.format_section())
 97 |         self.assertEqual((1920, 1080), section.get_resolution())
 98 | 
 99 |     def test_setting_property(self):
100 |         section = subs.ScriptInfoSection()
101 |         section.set_property("Random", 12.5)
102 |         section.set_property("teSt", "property")
103 |         self.assertEqual(["Random: 12.5", "teSt: property"], section.format_section())
104 | 
105 |         section.set_property("Random", "other value")
106 |         self.assertEqual(["Random: other value", "teSt: property"], section.format_section())
107 | 
108 |     def test_getting_property(self):
109 |         section = subs.ScriptInfoSection()
110 |         section.parse_line("Random: property")
111 | 
112 |         self.assertEqual("property", section.get_property("Random"))
113 | 
114 |         self.assertRaises(KeyError, lambda: section.get_property("property"))
115 |         self.assertRaises(KeyError, lambda: section.get_property("rAnDom"))
116 | 
117 | 
118 | 


--------------------------------------------------------------------------------
/tests/test_tools.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | import unittest
 3 | 
 4 | import tools
 5 | 
 6 | 
 7 | class TestTimecodes(unittest.TestCase):
 8 |     def test_frame_number_exact(self):
 9 |         timecodes = tools.Timecodes.cfr(fps=1.0)
10 |         self.assertEqual(0, timecodes.get_frame_number(0))
11 |         self.assertEqual(0, timecodes.get_frame_number(999))
12 |         self.assertEqual(1, timecodes.get_frame_number(1000))
13 |         self.assertEqual(1, timecodes.get_frame_number(1999))
14 |         self.assertEqual(100, timecodes.get_frame_number(100000))
15 | 
16 |     def test_get_frame_number_start(self):
17 |         timecodes = tools.Timecodes.cfr(fps=1.0)
18 |         self.assertEqual(0, timecodes.get_frame_number(0, timecodes.TIMESTAMP_START))
19 |         self.assertEqual(1, timecodes.get_frame_number(1, timecodes.TIMESTAMP_START))
20 |         self.assertEqual(1, timecodes.get_frame_number(1000, timecodes.TIMESTAMP_START))
21 |         self.assertEqual(2, timecodes.get_frame_number(1001, timecodes.TIMESTAMP_START))
22 |         self.assertEqual(100, timecodes.get_frame_number(100000, timecodes.TIMESTAMP_START))
23 | 
24 |     def test_get_frame_number_end(self):
25 |         timecodes = tools.Timecodes.cfr(fps=1.0)
26 |         self.assertEqual(-1, timecodes.get_frame_number(0, timecodes.TIMESTAMP_END))
27 |         self.assertEqual(0, timecodes.get_frame_number(1, timecodes.TIMESTAMP_END))
28 |         self.assertEqual(0, timecodes.get_frame_number(1000, timecodes.TIMESTAMP_END))
29 |         self.assertEqual(1, timecodes.get_frame_number(1001, timecodes.TIMESTAMP_END))
30 |         self.assertEqual(99, timecodes.get_frame_number(100000, timecodes.TIMESTAMP_END))
31 | 
32 |     def test_get_frame_time_exact(self):
33 |         timecodes = tools.Timecodes.cfr(fps=1.0)
34 |         self.assertEqual(0, timecodes.get_frame_time(0))
35 |         self.assertEqual(1000, timecodes.get_frame_time(1))
36 |         self.assertEqual(2000, timecodes.get_frame_time(2))
37 | 
38 |     def test_get_frame_time_start(self):
39 |         timecodes = tools.Timecodes.cfr(fps=1.0)
40 |         self.assertEqual(-500, timecodes.get_frame_time(0, timecodes.TIMESTAMP_START))
41 |         self.assertEqual(500, timecodes.get_frame_time(1, timecodes.TIMESTAMP_START))
42 |         self.assertEqual(1500, timecodes.get_frame_time(2, timecodes.TIMESTAMP_START))
43 | 
44 |     def test_get_frame_time_end(self):
45 |         timecodes = tools.Timecodes.cfr(fps=1.0)
46 |         self.assertEqual(500, timecodes.get_frame_time(0, timecodes.TIMESTAMP_END))
47 |         self.assertEqual(1500, timecodes.get_frame_time(1, timecodes.TIMESTAMP_END))
48 |         self.assertEqual(2500, timecodes.get_frame_time(2, timecodes.TIMESTAMP_END))
49 | 


--------------------------------------------------------------------------------
/tools.py:
--------------------------------------------------------------------------------
  1 | from common import PrassError
  2 | import bisect
  3 | import math
  4 | 
  5 | 
  6 | def parse_scxvid_keyframes(text):
  7 |     return [i-3 for i,line in enumerate(text.splitlines()) if line and line[0] == 'i']
  8 | 
  9 | 
 10 | def parse_keyframes(path):
 11 |     with open(path) as file_object:
 12 |         text = file_object.read()
 13 |     if text.find('# XviD 2pass stat file')>=0:
 14 |         frames = parse_scxvid_keyframes(text)
 15 |     else:
 16 |         raise PrassError('Unsupported keyframes type')
 17 |     if 0 not in frames:
 18 |         frames.insert(0, 0)
 19 |     return frames
 20 | 
 21 | 
 22 | class Timecodes(object):
 23 |     TIMESTAMP_END = 1
 24 |     TIMESTAMP_START = 2
 25 | 
 26 |     def __init__(self, times, default_fps):
 27 |         super(Timecodes, self).__init__()
 28 |         self.times = times
 29 |         self.default_frame_duration = 1000.0 / default_fps if default_fps else None
 30 | 
 31 |     def get_frame_time(self, number, kind=None):
 32 |         if kind == self.TIMESTAMP_START:
 33 |             prev = self.get_frame_time(number-1)
 34 |             curr = self.get_frame_time(number)
 35 |             return prev + int(round((curr - prev) / 2.0))
 36 |         elif kind == self.TIMESTAMP_END:
 37 |             curr = self.get_frame_time(number)
 38 |             after = self.get_frame_time(number+1)
 39 |             return curr + int(round((after - curr) / 2.0))
 40 | 
 41 |         try:
 42 |             return self.times[number]
 43 |         except IndexError:
 44 |             if not self.default_frame_duration:
 45 |                 raise ValueError("Cannot calculate frame timestamp without frame duration")
 46 |             past_end, last_time = number, 0
 47 |             if self.times:
 48 |                 past_end, last_time = (number - len(self.times) + 1), self.times[-1]
 49 | 
 50 |             return int(round(past_end * self.default_frame_duration + last_time))
 51 | 
 52 |     def get_frame_number(self, ms, kind=None):
 53 |         if kind == self.TIMESTAMP_START:
 54 |             return self.get_frame_number(ms - 1) + 1
 55 |         elif kind == self.TIMESTAMP_END:
 56 |             return self.get_frame_number(ms - 1)
 57 | 
 58 |         if self.times and self.times[-1] >= ms:
 59 |             return bisect.bisect_left(self.times, ms)
 60 | 
 61 |         if not self.default_frame_duration:
 62 |             raise ValueError("Cannot calculate frame for this timestamp without frame duration")
 63 | 
 64 |         if ms < 0:
 65 |             return int(math.floor(ms / self.default_frame_duration))
 66 | 
 67 |         last_time = self.times[-1] if self.times else 0
 68 |         return int((ms - last_time) / self.default_frame_duration) + len(self.times)
 69 | 
 70 |     @classmethod
 71 |     def _convert_v1_to_v2(cls, default_fps, overrides):
 72 |         # start, end, fps
 73 |         overrides = [(int(x[0]), int(x[1]), float(x[2])) for x in overrides]
 74 |         if not overrides:
 75 |             return []
 76 | 
 77 |         fps = [default_fps] * (overrides[-1][1] + 1)
 78 |         for start, end, fps in overrides:
 79 |             fps[start:end + 1] = [fps] * (end - start + 1)
 80 | 
 81 |         v2 = [0]
 82 |         for d in (1000.0 / f for f in fps):
 83 |             v2.append(v2[-1] + d)
 84 |         return v2
 85 | 
 86 |     @classmethod
 87 |     def parse(cls, text):
 88 |         lines = text.splitlines()
 89 |         if not lines:
 90 |             return []
 91 |         first = lines[0].lower().lstrip()
 92 |         if first.startswith('# timecode format v2'):
 93 |             tcs = [x for x in lines[1:]]
 94 |             return Timecodes(tcs, None)
 95 |         elif first.startswith('# timecode format v1'):
 96 |             default = float(lines[1].lower().replace('assume ', ""))
 97 |             overrides = (x.split(',') for x in lines[2:])
 98 |             return Timecodes(cls._convert_v1_to_v2(default, overrides), default)
 99 |         else:
100 |             raise PrassError('This timecodes format is not supported')
101 | 
102 |     @classmethod
103 |     def from_file(cls, path):
104 |         with open(path) as file:
105 |             return cls.parse(file.read())
106 | 
107 |     @classmethod
108 |     def cfr(cls, fps):
109 |         return Timecodes([], default_fps=fps)
110 | 


--------------------------------------------------------------------------------