if '/' in fps_string:

parts = fps_string.split('/')

if len(parts) > 2:

raise PrassError('Invalid fps value')

try:

return float(parts[0]) / float(parts[1])

except ValueError:

raise PrassError('Invalid fps value')

else:

try:

return float(fps_string)

except ValueError:

try:

if ':' in shift_string:

negator = 1

if shift_string.startswith('-'):

negator = -1

shift_string = shift_string[1:]

parts = list(map(float, shift_string.split(':')))

if len(parts) > 3:

raise PrassError("Invalid shift value: '{0}'".format(shift_string))

shift_seconds = sum(part * multiplier for part, multiplier in zip(reversed(parts), (1.0, 60.0, 3600.0)))

return shift_seconds * 1000 * negator # convert to ms

else:

if shift_string.endswith("ms"):

return float(shift_string[:-2])

elif shift_string.endswith("s"):

return float(shift_string[:-1]) * 1000

else:

return float(shift_string) * 1000

except ValueError:

if resolution_string == '720p':

return 1280,720

if resolution_string == '1080p':

return 1920,1080

for separator in (':', 'x', ","):

if separator in resolution_string:

width, _, height = resolution_string.partition(separator)

try:

return int(width), int(height)

except ValueError:

raise PrassError("Invalid resolution string: '{0}'".format(resolution_string))

"""Convert SRT script to ASS.

\b

Example:

$ prass convert-srt input.srt -o output.ass --encoding cp1251

"""

try:

with click.open_file(input_path, encoding=encoding) as input_file:

AssScript.from_srt_stream(input_file).to_ass_stream(output_file)

except LookupError:

"""Copy styles from one ASS script to another, write the result as a third script.

You always have to provide the "from" argument, "to" defaults to stdin and "output" defaults to stdout.

\b

Simple usage:

$ prass copy-styles --from template.ass --to unstyled.ass -o styled.ass

With pipes:

$ cat unstyled.ass | prass copy-styles --from template.ass | prass cleanup --comments -o out.ass

"""

src_script = AssScript.from_ass_stream(src_file)

dst_script = AssScript.from_ass_stream(dst_file)

if forced_resolution:

forced_resolution = parse_resolution_string(forced_resolution)

dst_script.append_styles(src_script, clean, resample, forced_resolution)

"""Sort script by one or more parameters.

\b

Sorting by time:

$ prass sort input.ass --by time -o output.ass

Sorting by time and then by layer, both in descending order:

$ prass sort input.ass --by time --by layer --desc -o output.ass

"""

script = AssScript.from_ass_stream(input_file)

attrs_map = {

"start": "start",

"time": "start",

"end": "end",

"style": "style",

"actor": "actor",

"effect": "effect",

"layer": "layer"

}

getter = attrgetter(*[attrs_map[x] for x in sort_by])

script.sort_events(getter, descending)

keyframes_path, timecodes_path, fps, kf_before_start, kf_after_start, kf_before_end, kf_after_end):

"""Timing post-processor.

It's a pretty straightforward port from Aegisub so you should be familiar with it.

You have to specify keyframes and timecodes (either as a CFR value or a timecodes file) if you want keyframe snapping.

All parameters default to zero so if you don't want something - just don't put it in the command line.

\b

To add lead-in and lead-out:

$ prass tpp input.ass --lead-in 50 --lead-out 150 -o output.ass

To make adjacent lines continuous, with 80% bias to changing end time of the first line:

$ prass tpp input.ass --overlap 50 --gap 200 --bias 80 -o output.ass

To snap events to keyframes without a timecodes file:

$ 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

"""

if fps and timecodes_path:

raise PrassError('Timecodes file and fps cannot be specified at the same time')

if fps:

timecodes = Timecodes.cfr(parse_fps_string(fps))

elif timecodes_path:

timecodes = Timecodes.from_file(timecodes_path)

elif any((kf_before_start, kf_after_start, kf_before_end, kf_after_end)):

raise PrassError('You have to provide either fps or timecodes file for keyframes processing')

else:

timecodes = None

if timecodes and not keyframes_path:

raise PrassError('You have to specify keyframes file for keyframes processing')

keyframes_list = parse_keyframes(keyframes_path) if keyframes_path else None

actual_styles = []

for style in styles:

actual_styles.extend(x.strip() for x in style.split(','))

script = AssScript.from_ass_stream(input_file)

script.tpp(actual_styles, lead_in, lead_out, max_overlap, max_gap, adjacent_bias,

keyframes_list, timecodes, kf_before_start, kf_after_start, kf_before_end, kf_after_end)

drop_actors, drop_effects, drop_spacing, drop_sections):

"""Remove junk data from ASS script

\b

To remove commented and empty lines plus clear unused styles:

$ prass cleanup input.ass --comments --empty-lines --styles output.ass

"""

sections_map = {

"fonts": "[Fonts]",

"graphics": "[Graphics]",

"aegi": "[Aegisub Project Garbage]",

"extradata": "[Aegisub Extradata]"

}

drop_sections = [sections_map[x] for x in drop_sections]

script = AssScript.from_ass_stream(input_file)

script.cleanup(drop_comments, drop_empty_lines, drop_unused_styles, drop_actors, drop_effects, drop_spacing, drop_sections)

"""Shift all lines in a script by defined amount.

\b

You can use one of the following formats to specify the time:

- "1.5s" or just "1.5" means 1 second 500 milliseconds

- "150ms" means 150 milliseconds

- "1:7:12.55" means 1 hour, 7 minutes, 12 seconds and 550 milliseconds. All parts are optional.

Every format allows a negative sign before the value, which means "shift back", like "-12s"

\b

To shift both start end end time by one minute and 15 seconds:

$ prass shift input.ass --by 1:15 -o output.ass

To shift only start time by half a second back:

$ prass shift input.ass --start --by -0.5s -o output.ass

"""

if not shift_start and not shift_end:

shift_start = shift_end = True

shift_ms = parse_shift_string(shift_by)

script = AssScript.from_ass_stream(input_file)

script.shift(shift_ms, shift_start, shift_end)