Module vtt_to_srt
23 | Convert of vtt to srt format
26 |
27 |
305 | 28 | Expand source code 29 |
30 |#!/usr/bin/python
31 | # Jansen A. Simanullang / Jeison Cardoso
32 |
33 | """Convert of vtt to srt format"""
34 |
35 | import os
36 | import re
37 | import argparse
38 | from string import Template
39 | from stat import S_ISDIR, ST_MODE, S_ISREG
40 |
41 |
42 | class VttToStr:
43 | """Convert vtt to srt"""
44 |
45 | def __init__(self) -> None:
46 | pass
47 |
48 | def convert_header(self, contents):
49 | """Convert of vtt header to srt format
50 |
51 | :contents -- contents of vtt file
52 | """
53 | replacement = re.sub(r"WEBVTT\n", "", contents)
54 | replacement = re.sub(r"Kind:[ \-\w]+\n", "", replacement)
55 | replacement = re.sub(r"Language:[ \-\w]+\n", "", replacement)
56 | return replacement
57 |
58 | def add_padding_to_timestamp(self, contents):
59 | """Add 00 to padding timestamp of to srt format
60 |
61 | :contents -- contents of vtt file
62 | """
63 | find_srt = Template(r'$a,$b --> $a,$b(?:[ \-\w]+:[\w\%\d:,.]+)*\n')
64 | minute = r"((?:\d\d:){1}\d\d)"
65 | second = r"((?:\d\d:){0}\d\d)"
66 | padding_minute = find_srt.substitute(a=minute, b=r"(\d{0,3})")
67 | padding_second = find_srt.substitute(a=second, b=r"(\d{0,3})")
68 | replacement = re.sub(
69 | padding_minute, r"00:\1,\2 --> 00:\3,\4\n", contents)
70 | return re.sub(padding_second, r"00:00:\1,\2 --> 00:00:\3,\4\n", replacement)
71 |
72 | def convert_timestamp(self, contents):
73 | """Convert timestamp of vtt file to srt format
74 |
75 | :contents -- contents of vtt file
76 | """
77 | find_vtt = Template(r'$a.$b --> $a.$b(?:[ \-\w]+:[\w\%\d:,.]+)*\n')
78 | all_timestamp = find_vtt.substitute(
79 | a=r"((?:\d\d:){0,2}\d\d)", b=r"(\d{0,3})")
80 | return self.add_padding_to_timestamp(re.sub(all_timestamp, r"\1,\2 --> \3,\4\n", contents))
81 |
82 | def convert_content(self, contents):
83 | """Convert content of vtt file to srt format
84 |
85 | :contents -- contents of vtt file
86 | """
87 | replacement = self.convert_timestamp(contents)
88 | replacement = self.convert_header(replacement)
89 | replacement = re.sub(r"<c[.\w\d]*>", "", replacement)
90 | replacement = re.sub(r"</c>", "", replacement)
91 | replacement = re.sub(r"<\d\d:\d\d:\d\d.\d\d\d>", "", replacement)
92 | replacement = re.sub(
93 | r"::[\-\w]+\([\-.\w\d]+\)[ ]*{[.,:;\(\) \-\w\d]+\n }\n", "", replacement)
94 | replacement = re.sub(r"Style:\n##\n", "", replacement)
95 | replacement = self.add_sequence_numbers(replacement)
96 |
97 | return replacement
98 |
99 | def has_timestamp(self, content):
100 | """Check if line is a timestamp srt format
101 |
102 | :contents -- contents of vtt file
103 | """
104 | return re.match(r"((\d\d:){2}\d\d),(\d{3}) --> ((\d\d:){2}\d\d),(\d{3})", content) is not None
105 |
106 | def add_sequence_numbers(self, contents):
107 | """Adds sequence numbers to subtitle contents and returns new subtitle contents
108 |
109 | :contents -- contents of vtt file
110 | """
111 | output = ''
112 | lines = contents.split('\n')
113 | i = 1
114 | for line in lines:
115 | if self.has_timestamp(line):
116 | output += str(i) + '\n'
117 | i += 1
118 | output += line + '\n'
119 | return output
120 |
121 | def write_file(self, filename: str, data, encoding_format: str = "utf-8"):
122 | """Create a file with some data
123 |
124 | :filename -- filename pat
125 | :data -- data to write
126 | :encoding_format -- encoding format
127 | """
128 | try:
129 | with open(filename, "w", encoding=encoding_format) as file:
130 | file.writelines(str(data))
131 | except IOError:
132 | filename = filename.split(os.sep)[-1]
133 | with open(filename, "w", encoding=encoding_format) as file:
134 | file.writelines(str(data))
135 | print(f"file created {filename}\n")
136 |
137 | def read_file(self, filename: str, encoding_format: str = "utf-8"):
138 | """Read a file text
139 |
140 | :filename -- filename path
141 | :encoding_format -- encoding format
142 | """
143 | content: str = ''
144 | with open(filename, mode="r", encoding=encoding_format) as file:
145 | print(f"file being read: {filename}\n")
146 | content = file.read()
147 |
148 | return content
149 |
150 | def process(self, filename: str, encoding_format: str = "utf-8"):
151 | """Convert vtt file to a srt file
152 |
153 | :str_name_file -- filename path
154 | :encoding_format -- encoding format
155 | """
156 | file_contents: str = self.read_file(filename, encoding_format)
157 | str_data: str = ""
158 | str_data = str_data + self.convert_content(file_contents)
159 | filename = filename.replace(".vtt", ".srt")
160 | self.write_file(filename, str_data, encoding_format)
161 |
162 |
163 | class ConvertFile:
164 | """Convert vtt file to srt file"""
165 |
166 | def __init__(self, pathname: str, encoding_format: str):
167 | """Constructor
168 |
169 | :pathname -- path to file or directory
170 | :encoding_format -- encoding format
171 | """
172 | self.pathname = pathname
173 | self.encoding_format = encoding_format
174 | self.vtt_to_str = VttToStr()
175 |
176 | def convert(self):
177 | """Convert vtt file to srt file"""
178 | if ".vtt" in self.pathname:
179 | self.vtt_to_str.process(self.pathname, self.encoding_format)
180 |
181 |
182 | class ConvertDirectories:
183 | """Convert vtt files to srt files"""
184 |
185 | def __init__(self, pathname: str, enable_recursive: bool, encoding_format: str):
186 | """Constructor
187 |
188 | pathname -- path to file or directory
189 | :enable_recursive -- enable recursive
190 | :encoding_format -- encoding format
191 | """
192 | self.pathname = pathname
193 | self.enable_recursive = enable_recursive
194 | self.encoding_format = encoding_format
195 | self.vtt_to_str = VttToStr()
196 |
197 | def _walk_dir(self, top_most_path: str, callback):
198 | """Walk a directory
199 |
200 | :top_most_path -- parent directory
201 | :callback -- function to call
202 | """
203 | for file in os.listdir(top_most_path):
204 | pathname = os.path.join(top_most_path, file)
205 | if not os.path.isdir(pathname):
206 | # It"s a file, call the callback function
207 | callback(pathname)
208 |
209 | def _walk_tree(self, top_most_path, callback):
210 | """Recursively descend the directory tree rooted at top_most_path,
211 | calling the callback function for each regular file
212 |
213 | :top_most_path -- parent directory
214 | :callback -- function to call
215 | """
216 | for file in os.listdir(top_most_path):
217 | pathname = os.path.join(top_most_path, file)
218 | mode = os.stat(pathname)[ST_MODE]
219 | if S_ISDIR(mode):
220 | # It's a directory, recurse into it
221 | self._walk_tree(pathname, callback)
222 | elif S_ISREG(mode):
223 | # It's a file, call the callback function
224 | callback(pathname)
225 | else:
226 | # Unknown file type, print a message
227 | print(f"Skipping {pathname}")
228 |
229 | def convert_vtt_to_str(self, file: str):
230 | """Convert vtt file to string
231 |
232 | :file -- file to convert
233 | """
234 | if ".vtt" in file:
235 | try:
236 | self.vtt_to_str.process(file, self.encoding_format)
237 | except UnicodeDecodeError:
238 | print(f"UnicodeDecodeError: {file}")
239 |
240 | def _vtt_to_srt_batch(self, directory: str):
241 | """Walk down directory searching for vtt files
242 |
243 | :directory -- path to search
244 | """
245 | top_most_path = directory
246 | if self.enable_recursive:
247 | self._walk_tree(top_most_path, self.convert_vtt_to_str)
248 | else:
249 | self._walk_dir(top_most_path, self.convert_vtt_to_str)
250 |
251 | def convert(self):
252 | """Convert vtt files to srt files"""
253 | self._vtt_to_srt_batch(self.pathname)
254 |
255 |
256 | def _show_usage():
257 | """Show a info message about the usage"""
258 | print("\nUsage:\tvtt_to_srt pathname [-r]\n")
259 | print("\tpathname\t- a file or directory with files to be converted")
260 | print("\t-r\t\t- walk path recursively\n")
261 |
262 |
263 | def _parse_args():
264 | """Parse command line arguments"""
265 | parser = argparse.ArgumentParser(
266 | description='Convert vtt files to srt files')
267 | parser.add_argument(
268 | "pathname", help="a file or directory with files to be converted")
269 | parser.add_argument("-r", "--recursive",
270 | help="walk path recursively", action="store_true")
271 | parser.add_argument("-e", "--encoding",
272 | help="encoding format for input and output files")
273 |
274 | args = parser.parse_args()
275 | return args
276 |
277 |
278 | def main():
279 | """main function"""
280 |
281 | args = _parse_args()
282 | pathname = args.pathname
283 | recursive = args.recursive
284 | encoding = args.encoding
285 |
286 | if not encoding:
287 | encoding = "utf-8"
288 |
289 | if os.path.isfile(pathname):
290 | print(f"file being converted: {pathname}\n")
291 | ConvertFile(pathname, encoding).convert()
292 |
293 | if os.path.isdir(pathname):
294 | print(f"directory being converted: {pathname}\n")
295 | ConvertDirectories(pathname, recursive, encoding).convert()
296 |
297 | if not os.path.isfile(pathname) and not os.path.isdir(pathname):
298 | print(f"pathname is not a file or directory: {pathname}\n")
299 | _show_usage()
300 |
301 |
302 | if __name__ == "__main__":
303 | main()Functions
312 |-
313 |
314 | def main() 315 |
316 | -
317 | 318 |
main function
319 |345 |320 | Expand source code 321 |
322 |
344 |def main(): 323 | """main function""" 324 | 325 | args = _parse_args() 326 | pathname = args.pathname 327 | recursive = args.recursive 328 | encoding = args.encoding 329 | 330 | if not encoding: 331 | encoding = "utf-8" 332 | 333 | if os.path.isfile(pathname): 334 | print(f"file being converted: {pathname}\n") 335 | ConvertFile(pathname, encoding).convert() 336 | 337 | if os.path.isdir(pathname): 338 | print(f"directory being converted: {pathname}\n") 339 | ConvertDirectories(pathname, recursive, encoding).convert() 340 | 341 | if not os.path.isfile(pathname) and not os.path.isdir(pathname): 342 | print(f"pathname is not a file or directory: {pathname}\n") 343 | _show_usage()
346 |
Classes
350 |-
351 |
352 | class ConvertDirectories 353 | (pathname: str, enable_recursive: bool, encoding_format: str) 354 |
355 | -
356 | 361 |
Convert vtt files to srt files
357 |Constructor
358 |pathname – path to file or directory 359 | :enable_recursive – enable recursive 360 | :encoding_format – encoding format
362 |438 |363 | Expand source code 364 |
365 |
437 |class ConvertDirectories: 366 | """Convert vtt files to srt files""" 367 | 368 | def __init__(self, pathname: str, enable_recursive: bool, encoding_format: str): 369 | """Constructor 370 | 371 | pathname -- path to file or directory 372 | :enable_recursive -- enable recursive 373 | :encoding_format -- encoding format 374 | """ 375 | self.pathname = pathname 376 | self.enable_recursive = enable_recursive 377 | self.encoding_format = encoding_format 378 | self.vtt_to_str = VttToStr() 379 | 380 | def _walk_dir(self, top_most_path: str, callback): 381 | """Walk a directory 382 | 383 | :top_most_path -- parent directory 384 | :callback -- function to call 385 | """ 386 | for file in os.listdir(top_most_path): 387 | pathname = os.path.join(top_most_path, file) 388 | if not os.path.isdir(pathname): 389 | # It"s a file, call the callback function 390 | callback(pathname) 391 | 392 | def _walk_tree(self, top_most_path, callback): 393 | """Recursively descend the directory tree rooted at top_most_path, 394 | calling the callback function for each regular file 395 | 396 | :top_most_path -- parent directory 397 | :callback -- function to call 398 | """ 399 | for file in os.listdir(top_most_path): 400 | pathname = os.path.join(top_most_path, file) 401 | mode = os.stat(pathname)[ST_MODE] 402 | if S_ISDIR(mode): 403 | # It's a directory, recurse into it 404 | self._walk_tree(pathname, callback) 405 | elif S_ISREG(mode): 406 | # It's a file, call the callback function 407 | callback(pathname) 408 | else: 409 | # Unknown file type, print a message 410 | print(f"Skipping {pathname}") 411 | 412 | def convert_vtt_to_str(self, file: str): 413 | """Convert vtt file to string 414 | 415 | :file -- file to convert 416 | """ 417 | if ".vtt" in file: 418 | try: 419 | self.vtt_to_str.process(file, self.encoding_format) 420 | except UnicodeDecodeError: 421 | print(f"UnicodeDecodeError: {file}") 422 | 423 | def _vtt_to_srt_batch(self, directory: str): 424 | """Walk down directory searching for vtt files 425 | 426 | :directory -- path to search 427 | """ 428 | top_most_path = directory 429 | if self.enable_recursive: 430 | self._walk_tree(top_most_path, self.convert_vtt_to_str) 431 | else: 432 | self._walk_dir(top_most_path, self.convert_vtt_to_str) 433 | 434 | def convert(self): 435 | """Convert vtt files to srt files""" 436 | self._vtt_to_srt_batch(self.pathname)Methods
439 |-
440 |
441 | def convert(self) 442 |
443 | -
444 | 445 |
Convert vtt files to srt files
446 |453 |447 | Expand source code 448 |
449 |
452 |def convert(self): 450 | """Convert vtt files to srt files""" 451 | self._vtt_to_srt_batch(self.pathname)
454 | 455 | def convert_vtt_to_str(self, file: str) 456 |
457 | -
458 | 460 |
Convert vtt file to string
459 |:file – file to convert
461 |475 |462 | Expand source code 463 |
464 |
474 |def convert_vtt_to_str(self, file: str): 465 | """Convert vtt file to string 466 | 467 | :file -- file to convert 468 | """ 469 | if ".vtt" in file: 470 | try: 471 | self.vtt_to_str.process(file, self.encoding_format) 472 | except UnicodeDecodeError: 473 | print(f"UnicodeDecodeError: {file}")
476 |
478 | 479 | class ConvertFile 480 | (pathname: str, encoding_format: str) 481 |
482 | -
483 | 487 |
Convert vtt file to srt file
484 |Constructor
485 |:pathname – path to file or directory 486 | :encoding_format – encoding format
488 |509 |489 | Expand source code 490 |
491 |
508 |class ConvertFile: 492 | """Convert vtt file to srt file""" 493 | 494 | def __init__(self, pathname: str, encoding_format: str): 495 | """Constructor 496 | 497 | :pathname -- path to file or directory 498 | :encoding_format -- encoding format 499 | """ 500 | self.pathname = pathname 501 | self.encoding_format = encoding_format 502 | self.vtt_to_str = VttToStr() 503 | 504 | def convert(self): 505 | """Convert vtt file to srt file""" 506 | if ".vtt" in self.pathname: 507 | self.vtt_to_str.process(self.pathname, self.encoding_format)Methods
510 |-
511 |
512 | def convert(self) 513 |
514 | -
515 | 516 |
Convert vtt file to srt file
517 |525 |518 | Expand source code 519 |
520 |
524 |def convert(self): 521 | """Convert vtt file to srt file""" 522 | if ".vtt" in self.pathname: 523 | self.vtt_to_str.process(self.pathname, self.encoding_format)
526 |
528 | 529 | class VttToStr 530 |
531 | -
532 | 533 |
Convert vtt to srt
534 |657 |535 | Expand source code 536 |
537 |
656 |class VttToStr: 538 | """Convert vtt to srt""" 539 | 540 | def __init__(self) -> None: 541 | pass 542 | 543 | def convert_header(self, contents): 544 | """Convert of vtt header to srt format 545 | 546 | :contents -- contents of vtt file 547 | """ 548 | replacement = re.sub(r"WEBVTT\n", "", contents) 549 | replacement = re.sub(r"Kind:[ \-\w]+\n", "", replacement) 550 | replacement = re.sub(r"Language:[ \-\w]+\n", "", replacement) 551 | return replacement 552 | 553 | def add_padding_to_timestamp(self, contents): 554 | """Add 00 to padding timestamp of to srt format 555 | 556 | :contents -- contents of vtt file 557 | """ 558 | find_srt = Template(r'$a,$b --> $a,$b(?:[ \-\w]+:[\w\%\d:,.]+)*\n') 559 | minute = r"((?:\d\d:){1}\d\d)" 560 | second = r"((?:\d\d:){0}\d\d)" 561 | padding_minute = find_srt.substitute(a=minute, b=r"(\d{0,3})") 562 | padding_second = find_srt.substitute(a=second, b=r"(\d{0,3})") 563 | replacement = re.sub( 564 | padding_minute, r"00:\1,\2 --> 00:\3,\4\n", contents) 565 | return re.sub(padding_second, r"00:00:\1,\2 --> 00:00:\3,\4\n", replacement) 566 | 567 | def convert_timestamp(self, contents): 568 | """Convert timestamp of vtt file to srt format 569 | 570 | :contents -- contents of vtt file 571 | """ 572 | find_vtt = Template(r'$a.$b --> $a.$b(?:[ \-\w]+:[\w\%\d:,.]+)*\n') 573 | all_timestamp = find_vtt.substitute( 574 | a=r"((?:\d\d:){0,2}\d\d)", b=r"(\d{0,3})") 575 | return self.add_padding_to_timestamp(re.sub(all_timestamp, r"\1,\2 --> \3,\4\n", contents)) 576 | 577 | def convert_content(self, contents): 578 | """Convert content of vtt file to srt format 579 | 580 | :contents -- contents of vtt file 581 | """ 582 | replacement = self.convert_timestamp(contents) 583 | replacement = self.convert_header(replacement) 584 | replacement = re.sub(r"<c[.\w\d]*>", "", replacement) 585 | replacement = re.sub(r"</c>", "", replacement) 586 | replacement = re.sub(r"<\d\d:\d\d:\d\d.\d\d\d>", "", replacement) 587 | replacement = re.sub( 588 | r"::[\-\w]+\([\-.\w\d]+\)[ ]*{[.,:;\(\) \-\w\d]+\n }\n", "", replacement) 589 | replacement = re.sub(r"Style:\n##\n", "", replacement) 590 | replacement = self.add_sequence_numbers(replacement) 591 | 592 | return replacement 593 | 594 | def has_timestamp(self, content): 595 | """Check if line is a timestamp srt format 596 | 597 | :contents -- contents of vtt file 598 | """ 599 | return re.match(r"((\d\d:){2}\d\d),(\d{3}) --> ((\d\d:){2}\d\d),(\d{3})", content) is not None 600 | 601 | def add_sequence_numbers(self, contents): 602 | """Adds sequence numbers to subtitle contents and returns new subtitle contents 603 | 604 | :contents -- contents of vtt file 605 | """ 606 | output = '' 607 | lines = contents.split('\n') 608 | i = 1 609 | for line in lines: 610 | if self.has_timestamp(line): 611 | output += str(i) + '\n' 612 | i += 1 613 | output += line + '\n' 614 | return output 615 | 616 | def write_file(self, filename: str, data, encoding_format: str = "utf-8"): 617 | """Create a file with some data 618 | 619 | :filename -- filename pat 620 | :data -- data to write 621 | :encoding_format -- encoding format 622 | """ 623 | try: 624 | with open(filename, "w", encoding=encoding_format) as file: 625 | file.writelines(str(data)) 626 | except IOError: 627 | filename = filename.split(os.sep)[-1] 628 | with open(filename, "w", encoding=encoding_format) as file: 629 | file.writelines(str(data)) 630 | print(f"file created {filename}\n") 631 | 632 | def read_file(self, filename: str, encoding_format: str = "utf-8"): 633 | """Read a file text 634 | 635 | :filename -- filename path 636 | :encoding_format -- encoding format 637 | """ 638 | content: str = '' 639 | with open(filename, mode="r", encoding=encoding_format) as file: 640 | print(f"file being read: {filename}\n") 641 | content = file.read() 642 | 643 | return content 644 | 645 | def process(self, filename: str, encoding_format: str = "utf-8"): 646 | """Convert vtt file to a srt file 647 | 648 | :str_name_file -- filename path 649 | :encoding_format -- encoding format 650 | """ 651 | file_contents: str = self.read_file(filename, encoding_format) 652 | str_data: str = "" 653 | str_data = str_data + self.convert_content(file_contents) 654 | filename = filename.replace(".vtt", ".srt") 655 | self.write_file(filename, str_data, encoding_format)Methods
658 |-
659 |
660 | def add_padding_to_timestamp(self, contents) 661 |
662 | -
663 | 665 |
Add 00 to padding timestamp of to srt format
664 |:contents – contents of vtt file
666 |683 |667 | Expand source code 668 |
669 |
682 |def add_padding_to_timestamp(self, contents): 670 | """Add 00 to padding timestamp of to srt format 671 | 672 | :contents -- contents of vtt file 673 | """ 674 | find_srt = Template(r'$a,$b --> $a,$b(?:[ \-\w]+:[\w\%\d:,.]+)*\n') 675 | minute = r"((?:\d\d:){1}\d\d)" 676 | second = r"((?:\d\d:){0}\d\d)" 677 | padding_minute = find_srt.substitute(a=minute, b=r"(\d{0,3})") 678 | padding_second = find_srt.substitute(a=second, b=r"(\d{0,3})") 679 | replacement = re.sub( 680 | padding_minute, r"00:\1,\2 --> 00:\3,\4\n", contents) 681 | return re.sub(padding_second, r"00:00:\1,\2 --> 00:00:\3,\4\n", replacement)
684 | 685 | def add_sequence_numbers(self, contents) 686 |
687 | -
688 | 690 |
Adds sequence numbers to subtitle contents and returns new subtitle contents
689 |:contents – contents of vtt file
691 |709 |692 | Expand source code 693 |
694 |
708 |def add_sequence_numbers(self, contents): 695 | """Adds sequence numbers to subtitle contents and returns new subtitle contents 696 | 697 | :contents -- contents of vtt file 698 | """ 699 | output = '' 700 | lines = contents.split('\n') 701 | i = 1 702 | for line in lines: 703 | if self.has_timestamp(line): 704 | output += str(i) + '\n' 705 | i += 1 706 | output += line + '\n' 707 | return output
710 | 711 | def convert_content(self, contents) 712 |
713 | -
714 | 716 |
Convert content of vtt file to srt format
715 |:contents – contents of vtt file
717 |737 |718 | Expand source code 719 |
720 |
736 |def convert_content(self, contents): 721 | """Convert content of vtt file to srt format 722 | 723 | :contents -- contents of vtt file 724 | """ 725 | replacement = self.convert_timestamp(contents) 726 | replacement = self.convert_header(replacement) 727 | replacement = re.sub(r"<c[.\w\d]*>", "", replacement) 728 | replacement = re.sub(r"</c>", "", replacement) 729 | replacement = re.sub(r"<\d\d:\d\d:\d\d.\d\d\d>", "", replacement) 730 | replacement = re.sub( 731 | r"::[\-\w]+\([\-.\w\d]+\)[ ]*{[.,:;\(\) \-\w\d]+\n }\n", "", replacement) 732 | replacement = re.sub(r"Style:\n##\n", "", replacement) 733 | replacement = self.add_sequence_numbers(replacement) 734 | 735 | return replacement
738 | 739 | def convert_header(self, contents) 740 |
741 | -
742 | 744 |
Convert of vtt header to srt format
743 |:contents – contents of vtt file
745 |758 |746 | Expand source code 747 |
748 |
757 |def convert_header(self, contents): 749 | """Convert of vtt header to srt format 750 | 751 | :contents -- contents of vtt file 752 | """ 753 | replacement = re.sub(r"WEBVTT\n", "", contents) 754 | replacement = re.sub(r"Kind:[ \-\w]+\n", "", replacement) 755 | replacement = re.sub(r"Language:[ \-\w]+\n", "", replacement) 756 | return replacement
759 | 760 | def convert_timestamp(self, contents) 761 |
762 | -
763 | 765 |
Convert timestamp of vtt file to srt format
764 |:contents – contents of vtt file
766 |779 |767 | Expand source code 768 |
769 |
778 |def convert_timestamp(self, contents): 770 | """Convert timestamp of vtt file to srt format 771 | 772 | :contents -- contents of vtt file 773 | """ 774 | find_vtt = Template(r'$a.$b --> $a.$b(?:[ \-\w]+:[\w\%\d:,.]+)*\n') 775 | all_timestamp = find_vtt.substitute( 776 | a=r"((?:\d\d:){0,2}\d\d)", b=r"(\d{0,3})") 777 | return self.add_padding_to_timestamp(re.sub(all_timestamp, r"\1,\2 --> \3,\4\n", contents))
780 | 781 | def has_timestamp(self, content) 782 |
783 | -
784 | 786 |
Check if line is a timestamp srt format
785 |:contents – contents of vtt file
787 |797 |788 | Expand source code 789 |
790 |
796 |def has_timestamp(self, content): 791 | """Check if line is a timestamp srt format 792 | 793 | :contents -- contents of vtt file 794 | """ 795 | return re.match(r"((\d\d:){2}\d\d),(\d{3}) --> ((\d\d:){2}\d\d),(\d{3})", content) is not None
798 | 799 | def process(self, filename: str, encoding_format: str = 'utf-8') 800 |
801 | -
802 | 805 |
Convert vtt file to a srt file
803 |:str_name_file – filename path 804 | :encoding_format – encoding format
806 |821 |807 | Expand source code 808 |
809 |
820 |def process(self, filename: str, encoding_format: str = "utf-8"): 810 | """Convert vtt file to a srt file 811 | 812 | :str_name_file -- filename path 813 | :encoding_format -- encoding format 814 | """ 815 | file_contents: str = self.read_file(filename, encoding_format) 816 | str_data: str = "" 817 | str_data = str_data + self.convert_content(file_contents) 818 | filename = filename.replace(".vtt", ".srt") 819 | self.write_file(filename, str_data, encoding_format)
822 | 823 | def read_file(self, filename: str, encoding_format: str = 'utf-8') 824 |
825 | -
826 | 829 |
Read a file text
827 |:filename – filename path 828 | :encoding_format – encoding format
830 |846 |831 | Expand source code 832 |
833 |
845 |def read_file(self, filename: str, encoding_format: str = "utf-8"): 834 | """Read a file text 835 | 836 | :filename -- filename path 837 | :encoding_format -- encoding format 838 | """ 839 | content: str = '' 840 | with open(filename, mode="r", encoding=encoding_format) as file: 841 | print(f"file being read: {filename}\n") 842 | content = file.read() 843 | 844 | return content
847 | 848 | def write_file(self, filename: str, data, encoding_format: str = 'utf-8') 849 |
850 | -
851 | 855 |
Create a file with some data
852 |:filename – filename pat 853 | :data – data to write 854 | :encoding_format – encoding format
856 |875 |857 | Expand source code 858 |
859 |
874 |def write_file(self, filename: str, data, encoding_format: str = "utf-8"): 860 | """Create a file with some data 861 | 862 | :filename -- filename pat 863 | :data -- data to write 864 | :encoding_format -- encoding format 865 | """ 866 | try: 867 | with open(filename, "w", encoding=encoding_format) as file: 868 | file.writelines(str(data)) 869 | except IOError: 870 | filename = filename.split(os.sep)[-1] 871 | with open(filename, "w", encoding=encoding_format) as file: 872 | file.writelines(str(data)) 873 | print(f"file created {filename}\n")
876 |
878 |