Esempio n. 1
0
def readAllFiles(path):
  for root, dirs, files in os.walk(path):
    files.sort()
    for fileread in files:
      if fileread.endswith(".scenes"):
        with open(path + fileread) as a_file:
          lines = a_file.readlines()
          fileName = lines[0].rstrip()
          del lines[0]
          number = 1
          listSrt = list()
          for item in lines:
            lhs, rhs = item.split(",", 1)
            partName, ext = fileName.split(".", 1)
            newPath = path + 'parted/'
            if not os.path.exists(newPath):
              os.makedirs(newPath)
            newFileNameMovie = newPath + partName + '_' + str(number) + '.mp4'
            newFileNameSrt = newPath + partName + '_' + str(number) + '.srt'
            number += 1

            # Split movie file
            # ffmpeg -i video.mp4 -ss 00:01:00 -to 00:02:00 -c copy cut.mp4
            # ffmpeg -i input.avi -c:v libx264 -crf 19 -preset slow -c:a libfaac -b:a 192k -ac 2 out.mp4
            try:
              if ext == 'mp4':
                os.system('ffmpeg -i "%s" -ss "%s" -to "%s" -c copy "%s" ' % (
                  path + fileName, lhs, rhs.rstrip(), newFileNameMovie))
              else:
                os.system('ffmpeg -i "%s" -ss "%s" -to "%s" -c:v libx264 -c:a copy "%s" ' % (
                  path + fileName, lhs, rhs.rstrip(), newFileNameMovie))
            except:
              print "Error with spliting movie file"

            # Split *.srt file
            try:
              #subs = SubRipFile.open(path + partName + '.srt')
              try:
                subs = pysrt.open(path + partName + '.srt')
              except UnicodeDecodeError:
                subs = pysrt.open(path + partName + '.srt',encoding='iso-8859-1')
              Hs, Ms, Ss = lhs.split(":", 2)
              He, Me, Se = rhs.split(":", 2)
              part = subs.slice(starts_after={'hours': int(Hs), 'minutes': int(Ms), 'seconds': int(Ss)},
                                ends_before={'hours': int(He), 'minutes': int(Me), 'seconds': int(Se)})
              part.save(newFileNameSrt)
              listSrt.append(newFileNameSrt)
            # part.shift(hours=-int(Hs), minutes=-int(Ms), seconds=-int(Ss))
            except:
              print "Error with spliting srt file"
          if not listSrt:
            print "Error there are no srt files"
          else:
            """
            srtdir = path+'wholeSrt/'
            ensure_dir(srtdir)
            srtmerge(listSrt, srtdir + partName + '_new.srt', offset=1000)
            srtToTxt(path+'wholeSrt/')
            """
            srtToTxt(newPath)
Esempio n. 2
0
def _detect_subtitle_language(srt_path):
    log.debug('Detecting subtitle language')

    # Load srt file (try first iso-8859-1 with fallback to utf-8)
    try:
        subtitle = pysrt.open(path=srt_path, encoding='iso-8859-1')
    except Exception:
        try:
            subtitle = pysrt.open(path=srt_path, encoding='utf-8')
        except Exception:
            # If we can't read it, we can't detect, so return
            return None

    # Read first 5 subtitle lines to determine the language
    if len(subtitle) >= 5:
        text = ''
        for sub in subtitle[0:5]:
            text += sub.text

        # Detect the language with highest probability and return it if it's more than the required minimum probability
        detected_languages = langdetect.detect_langs(text)
        log.debug('Detected subtitle language(s): %s', detected_languages)
        if len(detected_languages) > 0:
            # Get first detected language (list is sorted according to probability, highest first)
            detected_language = detected_languages[0]
            language_probability = detected_language.prob
            if language_probability >= autosubliminal.DETECTEDLANGUAGEPROBABILITY:
                log.debug('Probability of detected subtitle language accepted: %s', detected_language)
                return Language.fromietf(detected_language.lang)
            else:
                log.debug('Probability of detected subtitle language too low: %s', detected_language)

    return None
def get_word_freq_dict(inputfiles, verification_list):
    freq_dict = {}
    for inputfile in inputfiles:
        print 'processing', inputfile
        subs = []
        try:
            subs = pysrt.open(inputfile)
        except UnicodeDecodeError as e:
            subs = []
        if not subs:
            for enc in ['utf8',"iso-8859-1"]:
                try:
                    print 'trying with' , enc
                    subs =  pysrt.open(inputfile, encoding=enc)
                except UnicodeDecodeError as e:
                    subs =[]
                if subs:
                    break
        if not subs:
            print 'couldnt open ', inputfile
            continue
        for sub in subs:
            words = sub.text.split()        
            for w in words:
                insert_word(freq_dict, w, verification_list)
        print len(freq_dict), sum(freq_dict.values())
    return freq_dict
    def collect_subtitles_lines(self, subtitle_file, file_path=None):
        if not file_path:
            file_path = os.path.join(
                subtitle_file.directory, subtitle_file.file_name)
        try:
            subs = pysrt.open(file_path)
        except UnicodeDecodeError:
            subs = pysrt.open(
                file_path,
                encoding='iso-8859-1')

        for sub in subs:
            start = str(datetime.timedelta(
                milliseconds=sub.start.ordinal))
            end = str(datetime.timedelta(
                milliseconds=sub.end.ordinal))
            text = sub.text
            try:
                line = SubtitlesLine.objects.create(
                    subtitlefile=subtitle_file,
                    index=sub.index,
                    start=str(start),
                    end=str(end),
                    text=text,
                )
            except (ValidationError, ValueError) as e:
                print 'Ignoring: {t}'.format(t=text.encode('utf8'))
                continue

            line.text_vector = SearchVector(
                'text', config=subtitle_file.language)
            line.save()
Esempio n. 5
0
def join_srt_files(srt_top, srt_btm, srt_out):
    """Join two subtitles and save result.
    """
    top = pysrt.open(srt_top)
    btm = pysrt.open(srt_btm)

    merged = pysrt.SubRipFile(items=btm)
    for item in top:
        item.text = TOP_SRT_TEMPLATE.format(item.text)
        merged.append(item)

    merged.sort()
    merged.clean_indexes()
    merged.save(srt_out)
Esempio n. 6
0
def srtToTxt(dirName):
  for infile in glob.glob(os.path.join(dirName, '*.srt')):
    # os.system("iconv --from-code=ISO-8859-1 --to-code=UTF-8 \"" + infile + "\" > \"" + infile2 + "\"")
    #subs = SubRipFile.open(infile)
    try:
      subs = pysrt.open(infile)
    except UnicodeDecodeError:
      subs = pysrt.open(infile,encoding='iso-8859-1')
    outfile = infile[:-4] + '.txt'
    f = codecs.open(outfile, "w", encoding="utf-8")
    #f = open(outfile, 'w')
    for i in range(len(subs)):
      f.write(subs[i].text)
    f.close()
Esempio n. 7
0
def emptyEntries(myFile, keep, verbose):
    emptyEntryFound = False
    emptyEntries = 0
    entriesToDelete = []

    if verbose:
        print "--- Searching for empty entries"
    subs = pysrt.open(myFile, encoding='utf-8')  # open sub with pysrt as utf-8
    entries = len(subs)  # count entries
    if verbose:
        print "--- %s entries total" % entries

    for entryNo in range(0, entries):  # count entry numbers up to number of entries
        subEntry = u"%s" % subs[entryNo]  # read single entry
        lines = subEntry.split('\n')  # split entry into lines
        lineNo = 0  # set first line to 0
        emptyEntry = False

        for row in lines:  # read lines one by one
            if lineNo == 2:
                if (row == " " 
                    or row == "&nbsp" 
                    or not row):  # if third line is   or empty
                    emptyEntry = True
            if emptyEntry and lineNo == 3 and row == "":  # if third line is   and fourth line is empty
                emptyEntryFound = True
                emptyEntries += 1
                entriesToDelete.append(entryNo)  # add entry number to list
            lineNo += 1

    if emptyEntryFound:  # if empty entry is found
        print "*** %s empty entries found" % emptyEntries

        for entryNo in reversed(entriesToDelete):  # run through entry numbers in reverse
            # print lineNo
            del subs[entryNo]  # delete entry
            
        if keep:
            if verbose:
                print "--- Copying original file to %s.emptyEntries" % myFile
            copyfile(myFile, "%s.emptyEntries" % myFile)
            
        subs.save(myFile, encoding='utf-8')  # save sub

        subs = pysrt.open(myFile, encoding='utf-8')  # open new sub with pysrt
        entries = len(subs)  # count entries
        print "--- Now has %s entries" % entries
        
    return emptyEntryFound
Esempio n. 8
0
def extract_lines(subtitle_path):
    try:
        subtitle_object = pysrt.open(subtitle_path)
    except UnicodeDecodeError:
        subtitle_object = pysrt.open(subtitle_path, encoding='latin1')
    subtitle_lines = []
    for sub in subtitle_object:
        text = sub.text
        # Removing any formatting via HTML tags
        text = re.sub('<[^<]+?>', '', text)
        # Skipping links (usually ads or subtitle credits so irrelevant)
        if re.search(URL_REGEX, text):
            continue
        subtitle_lines.append(text)
    return subtitle_lines
Esempio n. 9
0
def parseSubs(subtitles):
	for filename in os.listdir(SUB_PATH_BASE_DIR):
		print ("Parsing srt file: " + filename)
		try:
			subs = pysrt.open(SUB_PATH_BASE_DIR+filename)
		except:
			print "Could not parse "+ filename
			continue
		for i in xrange(len(subs)):
			sub = subs[i]
			if i != len(subs)-1:
				# some subbers are crazy impatient! subs drop out prematurely
				# given a threshold for about 2 seconds, we will extend the sub up to
				# 1 second based on the start time of the next subtitle
				nextSub = subs[i+1]
				timeToNextSub = nextSub.start - sub.end
				secondsToNextSub = timeToNextSub.seconds + timeToNextSub.milliseconds/1000.0
				if secondsToNextSub <= 2:
					sub.end.seconds += secondsToNextSub/2.0
				else:
					sub.end.seconds += 1


			if (len(sub.text.split()) == 0): continue
			CurrentSubtitle = Subtitle(sub, filename)
			subtitles.append(CurrentSubtitle)
Esempio n. 10
0
    def _read_subtitle(self, subtitle_filename):
        """Read the subtitle file and output dialogs.
        """
        subtitle_text = pysrt.open(subtitle_filename, encoding='iso-8859-1')
        subtitle_text = [l.strip() for l in subtitle_text.text.split('\n')]
        subtitle_text = [quote_matches.sub('', l).strip() for l in subtitle_text]

        # Prepare dialogs
        dialogs = []
        create_new_dialog = True
        for l in subtitle_text:
            if not l: # Get rid of newlines
                continue
            if create_new_dialog:
                dialogs.append([l])  # Start new dialog
            else:
                dialogs[-1].append(l)  # Append to last dialog

            # Decide what to do with next line based on current line ending
            create_new_dialog = False
            if l[-1] in ['.', '!', '?', ':', ')']:
                create_new_dialog = True

        # Join the lists to form single dialogs
        for d in range(len(dialogs)):
            dialogs[d] = ' '.join(dialogs[d])

        return dialogs
Esempio n. 11
0
def parse_srt(sub_file=None):
    sub_file = sub_file or get_random_srt()

    debug(u"Using {} as SRT".format(sub_file))

    try:
        subs = srt.open(sub_file)
    except:
        subs = srt.open(sub_file, "latin1")

    flat_subs = subs.text.replace("\n", " ")
    clean_subs = junk_re.sub(" ", flat_subs)
    piece_iter = iter(split_re.split(clean_subs))
    split_subs = [l+next(piece_iter, '').strip() for l in piece_iter]

    return split_subs
Esempio n. 12
0
 def handle_subtitle(cls, filename, target=None, to='zh', by_words=True):
     subs = pysrt.open(filename)
     words_list = cls.init_word_list()
     for sub in subs:
         if by_words:
             result = ''
             result_dict = BaiduTranslate.translate(sub.text.replace(' ', '\n'))
             for k in result_dict:
                 if cls.is_word_valid(k, words_list):
                     result += k + '(' + result_dict.get(k) + ') '
                 else:
                     result += k + ' '
             sub.text = result
             print(result)
         else:
             try:
                 result = BaiduTranslate.translate(sub.text, to=to)
             except requests.exceptions.ReadTimeout:
                 time.sleep(10)
                 BaiduTranslate.log('HTTP TIME OUT : ' + sub.text)
                 continue
             for r in result:
                 sub.text += '\n' + result[r]
     subs.save(target or filename + '.' + to + '.srt')
     return True
Esempio n. 13
0
    def download_sub(self):
        print 'Validation: ' + str(self.validate)
        if self.validate:
            validate = Validate(self.movie_path)

        chain_iterators = chain(DBSub().download_sub(self.movie_path),
                                OpenSubs().download_sub(self.movie_path))

        for file_path in chain_iterators:
            if self.validate:
                subs = pysrt.open(file_path)
                text_slices = subs.slice(starts_after={'minutes': validate.start_min - 1, 'seconds': 59},
                                         ends_before={'minutes': validate.start_min,
                                                      'seconds': 11})
                text = ''
                for t_slice in text_slices.data:
                    text = text + t_slice.text + ' '
                text = ' '.join(text.split())
                print("For file : {} Movie Text is : {}".format(file_path, text))
                if validate.validate(text):
                    print("Found validated subtitle")
                    self._final(True)
                    return
                os.remove(file_path)
            else:
                continue
        self._final(False)
Esempio n. 14
0
	def start(text_input,language_analysis_stimulated):
		#time.sleep(0.3) # Wait 0.5 seconds for other processes's start
		t0 = time.time() # Initiation time
		if os.path.exists(text_input): # If captions file exist
			subs = pysrt.open(text_input) # Get whole subtitles
			i = 0 # Step counter
			while i < len(subs): # While step counter less than amount of subtitles
				time.sleep(0.1) # Wait 0.5 seconds to prevent aggressive loop
				if (time.time() - t0 + 0.8) > subs[i].start.seconds: # If current time is greater than subtitle's start
					sub_starting_time = datetime.datetime.now() # Starting time of the memory
					language_analysis_stimulated.value = 1 # Language analysis stimulated
					sub_ending_time = sub_starting_time + datetime.timedelta(seconds=(subs[i].end - subs[i].start).seconds) # Calculate the ending time by subtitle's delta
					sub = subs[i].text.encode('ascii','ignore') # Encode subtitle's text by ascii and assign to sub variable
					sub = sub.translate(None, '!@#$?,')
					words = sub.split()
					phone_groups = []
					for word in words:
						phone_groups.append(LanguageAnalyzer.word_to_phones(word))
					phones = " ".join(phone_groups)
					phone_duration = datetime.timedelta(seconds=(subs[i].end - subs[i].start).seconds) / len(phones)
					starting_time = sub_starting_time
					for word_inphones in phone_groups:
						ending_time = starting_time + phone_duration * len(word_inphones.split())
						if ending_time <= sub_ending_time and word_inphones != "":
							process5 = multiprocessing.Process(target=LanguageMemoryUtil.add_memory, args=(word_inphones, starting_time, ending_time)) # Define write memory process
							process5.start() # Start write memory process
						starting_time = ending_time + datetime.timedelta(milliseconds=50)
					print subs[i].text + "\n" # Print subtitle's text
					print phones + "\n"
					print "_____________________________________________________________________________________\n"

					language_analysis_stimulated.value = 0 # Language analysis NOT stimulated
					i  += 1 # Increase step counter
		else: # If captions file doesn't exist
			raise ValueError('VTT file doesn\'t exist!') # Raise a ValueError
Esempio n. 15
0
    def cut_subtitle(self):
        sbt_in = self.subtitle_pick.get_text()
        if os.path.isfile(sbt_in):
            sbt_out = self.save_pick.get_text() + os.path.splitext(sbt_in)[1]
            h1, m1, s1 = self.start.get_h_m_s()
            h2, m2, s2 = self.stop.get_h_m_s()
            import chardet

            detected = chardet.detect(open(sbt_in, "rb").read(1024 * 1024))
            enc = detected["encoding"]
            cnf = detected["confidence"]
            e = None
            encs = OrderedSet([enc, "utf-8", "latin1"])
            for encoding in encs:
                try:
                    logger.info("Trying to open subtitle with encoding %s" % encoding)
                    subs = pysrt.open(sbt_in, error_handling=pysrt.ERROR_LOG, encoding=encoding)
                    subtitle_cut(h1, m1, s1, h2, m2, s2, subs, sbt_out)
                    return
                except Exception as ae:
                    e = e or ae
                    logger.warning("encoding  %s failed", encoding, exc_info=1)
            msg = (
                "Could not open {} with any of the following encodings:\n  {}\n\n"
                "Confidence on {} was {}.\nFirst error was: {}"
            )
            msg = msg.format(os.path.basename(sbt_in), ", ".join(encs), enc, cnf, str(e))
            QMessageBox.warning(self, "Opening subtitle failed", msg, defaultButton=QMessageBox.NoButton)

            return sbt_out
Esempio n. 16
0
def ldSrtFile(path):
  # check out the param

  subs = pysrt.open(path)
  if len(subs) == 0:
    return false
  else:
    return subs
def main():
    """
    This is the main method. It inits and executes the argparser.
    Loops over all subs
    """
    parser = argparse.ArgumentParser(
        description='This scipt helps to customize '
        'the .srt file of a DJI Phantom 3.')
    parser.add_argument('-i', '--input',
                        help='input .srt file', required=True)
    parser.add_argument('-o', '--output',
                        help='output .srt file', required=True)
    parser.add_argument('-hb', '--barometer', action='store_true',
                        help='add barometer height')
    parser.add_argument('-hu', '--ultrasonic', action='store_true',
                        help='add ultrasonic height')
    parser.add_argument('-da', '--date', action='store_true',
                        help='add date of flight')
    parser.add_argument('-ti', '--time', action='store_true',
                        help='add time of flight')
    parser.add_argument('-du', '--duration', action='store_true',
                        help='add duration of flight')
    parser.add_argument('-sp', '--speed', action='store_true',
                        help='add speed')
    parser.add_argument('-l', '--label', action='store_true',
                        help='add text label to each piece of data')
    args = parser.parse_args()

    if not (args.barometer or args.ultrasonic or args.date or args.time or
            args.duration or args.speed):
        print('Please specify some data to add!\n')
        parser.print_help()
        return -1

    subs = pysrt.open(args.input)

    for s in subs:
        t = ''
        for token in re.split(' |\n', s.text):
            if args.barometer:
                t += filter_height(token=token, ultrasonic=False,
                                   use_label=args.label)
            if args.ultrasonic:
                t += filter_height(token=token, ultrasonic=True,
                                   use_label=args.label)
            if args.date:
                t += filter_date(token=token, use_label=args.label)
            if args.time:
                t += filter_time(token=token, use_label=args.label)
            if args.duration:
                t += compute_duration(token=token, use_label=args.label)
            if args.speed:
                t += compute_speed(token=token, use_label=args.label)

        s.text = t

    subs.save(args.output, encoding='utf-8')
    return 0
Esempio n. 18
0
def parseSrt(file, overlap, output):
    subs = pysrt.open(file)
    entries = len(subs)

    fullText = subs[0].text.replace('\n', ' ')
    timeArray = ''

    if overlap:
        subs.shift(seconds=-3)

    time = getTimeInMilliseconds(subs[0].start)
    end = getTimeInMilliseconds(subs[0].end)
    difference = end - time

    text = subs[0].text.replace('\n', ' ')
    textArray = text.split(' ')

    if overlap:
        for x in xrange(0,len(textArray)):
            time += (difference / len(textArray))
            timeArray += str(time) + ' '
        print(timeArray)
    else:
        for x in xrange(0,len(textArray)):
            time += (difference / len(textArray))
            timeArray += str(time) + ' '

    # for all subtitle entries
    for x in xrange(1,entries):
        sub = subs[x]

        time = getTimeInMilliseconds(sub.start)
        end = getTimeInMilliseconds(sub.end)
        difference = end - time

        text = sub.text.replace('\n', ' ')
        textArray = text.split(' ')

        if overlap:
            fullText += ' ' + textArray[len(textArray) - 1]
            timeArray += str(end) + ' '
        else:
            fullText += ' ' + text
            for x in xrange(0,len(textArray)):
                time += (difference / len(textArray))
                timeArray += str(time) + ' '
    
    # remove tailing whitespace
    timeArray = timeArray[:-1]

    print(len(fullText.split(' ')))
    print(len(timeArray.split(' ')))
    if output:
        text_file = open(output, "w")
        text_file.write(fullText.encode('UTF-8'))
        text_file.write('\n\n')
        text_file.write(timeArray)
        text_file.close()
Esempio n. 19
0
def get_subtitles(srt_filename):
    episode_subtitles = pd.DataFrame(columns=['start', 'end', 'text'])
    subs = pysrt.open(srt_filename)
    subs.shift(seconds=0)
    for i, sub in enumerate(subs):
        episode_subtitles.loc[i] = [int(sub.start.minutes) * 60 + int(sub.start.seconds) + sub.start.milliseconds/1000,
                                    int(sub.end.minutes) * 60 + int(sub.end.seconds) + sub.end.milliseconds/1000,
                                    sub.text]
    return episode_subtitles
Esempio n. 20
0
 def loadSubtitles(self):
     if ".srt" in self.reader.currentFile.loadedExtensions:
         self.srt = pysrt.open(self.reader.currentFile.name+".srt")
         for x in self.srt:
             x.text = " ".join(x.text.split("\n"))
         self.srt.save(self.reader.currentFile.name+".srt",encoding="utf-8")
         entireText = "\n".join([i.text for i in self.srt])
         #if self.reader.textContent.toPlainText() == "":
         self.reader.textContent.setPlainText(entireText)
Esempio n. 21
0
def getSubtitles(srtFile):

    episodeSubtitles = pd.DataFrame(columns=['start','end','text'])
    subs = pysrt.open(srtFile)
    subs.shift(seconds=5)
    for i,sub in enumerate(subs):
        episodeSubtitles.loc[i] = [int(sub.start.minutes)*60+int(sub.start.seconds),
                                   int(sub.end.minutes)  *60+int(sub.end.seconds),
                                  sub.text]
    return(episodeSubtitles)
Esempio n. 22
0
def test_sentiment_api():
    subs = pysrt.open("subtitles/" + 'S01E01' + ".srt")
    total_text = ""
    for sub in subs:
        total_text += sub.text.replace('\n', ' ').replace('<i>', '').replace('</i>', '').replace("\'", '').replace("?", ' ')
    form = dict(text="love love love")
    r = requests.post("http://text-processing.com/api/sentiment/", data=form)

    unicode_sentiment = r.text.encode("utf-8")
    print json.loads(r.text.encode("utf-8"))['probability']['neg']
Esempio n. 23
0
    def test_eol_conversion(self):
        input_file = open(self.windows_path, "rU", encoding="windows-1252")
        input_file.read()
        self.assertEqual(input_file.newlines, "\r\n")

        srt_file = pysrt.open(self.windows_path, encoding="windows-1252")
        srt_file.save(self.temp_path, eol="\n")

        output_file = open(self.temp_path, "rU", encoding="windows-1252")
        output_file.read()
        self.assertEqual(output_file.newlines, "\n")
Esempio n. 24
0
    def test_eol_conversion(self):
        input_file = open(self.windows_path, 'rU')
        input_file.read()
        self.assertEquals(input_file.newlines, '\r\n')

        srt_file = pysrt.open(self.windows_path, encoding='windows-1252')
        srt_file.save(self.temp_path, eol='\n')

        output_file = open(self.temp_path, 'rU')
        output_file.read()
        self.assertEquals(output_file.newlines, '\n')
Esempio n. 25
0
def main(argv):
    parser = argparse.ArgumentParser(description='FFmpegConveter')
    parser.add_argument('-i', dest='input', required=True, help='input file', metavar='FILE')
    parser.add_argument('-s', dest='subtitlesSize', type=int , default=23)
    
    args = parser.parse_args()
    path = args.input
    subtitlesSize = args.subtitlesSize
    print 'Processing:\t', os.path.basename(path)
    
    commands = []
    commands.append('ffmpeg')
    commands.append('-i "' + path + '"')
    commands.append('-vcodec h264')
    commands.append('-vprofile high')
    commands.append('-preset superfast')
    commands.append('-threads 0')
    commands.append('-acodec ac3')
    commands.append('-map 0:v:0')
    commands.append('-map 0:a')
    commands.append('-fs 2100000000')
    
    length = getLength(path)
    size = os.path.getsize(path)
    pathSRT = changeExtension(path, 'srt')
    
    if not os.path.isfile(pathSRT):
        if not helper.query_yes_no('Subtitles not found, continue?'):
            quit()
    
    crf = getCRF((size / length) / 1000)
    if crf > 0:
        commands.append('-crf ' + str(crf))
    
    part = 1
    lengthParts = 0
    while lengthParts + (2 * part) < length:
        commandsT = list(commands)
        outputPath = createOutputPath(path, '_' + str(part))
        outputPath = changeExtension(outputPath, 'mkv')
        
        if os.path.isfile(pathSRT):
            with tempfile.NamedTemporaryFile(dir='tmp', suffix='.srt', delete=False) as tmpfile:
                subs = pysrt.open(pathSRT)
                subs.shift(seconds=-lengthParts)
                subs.save(tmpfile.name)
                commandsT.append('-vf "subtitles=\'' + os.path.relpath(tmpfile.name).replace('\\', '\\\\') + '\':force_style=\'Fontsize=' + str(subtitlesSize) + '\'"')
        
        commandsT.insert(1, '-ss ' + str(lengthParts))
        commandsT.append('"' + outputPath + '"')
        
        executeCommands(commandsT)
        lengthParts = lengthParts + getLength(outputPath) - 2
        part = part + 1
Esempio n. 26
0
def numbering(myFile, keep, verbose):
    wrongNumbering = False

    if verbose:
        print "--- Checking numbering"

    subs = pysrt.open(myFile, encoding='utf-8')  # open sub with pysrt as utf-8
    entries = len(subs)  # count entries

    for entryNo in range(0, entries):  # count entry numbers up to number of entries
        subEntry = "%s" % subs[entryNo]  # read single entry
        lines = subEntry.split('\n')  # split entry into lines
        if entryNo + 1 != int(lines[0]):  # entry number does not match real numbering
            wrongNumbering = True
            print "*** Correcting numbering"
            copyfile(myFile, "%s.wrongNumbering" % myFile)
            break

    if wrongNumbering:
        targetFile = codecs.open(myFile, "w", prefEncoding)
        subs = pysrt.open("%s.wrongNumbering" % myFile, encoding='utf-8')  # open sub with pysrt as utf-8
        entries = len(subs)  # count entries
        for entryNo in range(0, entries):  # count entry numbers up to number of entries
            subEntry = "%s" % subs[entryNo]  # read single entry
            lines = subEntry.split('\n')  # split entry into lines
            noLines = len(lines)  # number of lines in each entry
            for line in range(0, noLines):
                if line == 0:
                    targetFile.write("%s\n" % str(entryNo + 1))
                    # print entryNo + 1
                else:
                    targetFile.write("%s\n" % lines[line])
                    # print lines[line]
        targetFile.close()

        if not keep:
            if verbose:
                print "--- Deleting %s.wrongNumbering" % myFile
            os.remove("%s.wrongNumbering" % myFile)

    return wrongNumbering
Esempio n. 27
0
def find_gif(subsfile,query):
	subs = pysrt.open(subsfile)
	start = 0
	duration = 0
	print(query)
	for sub in subs:
		text = " ".join(sub.text.lower().split())
		if query in text:
			start = datetime.strptime(str(sub.start),"%H:%M:%S,%f").strftime("%H:%M:%S")
			duration = (datetime.strptime(str(sub.end),"%H:%M:%S,%f")-datetime.strptime(str(sub.start),"%H:%M:%S,%f")).seconds
			break	
	return start,duration
Esempio n. 28
0
    def read(self, path, uri=None, **kwargs):
        """Load .srt file as transcription

        Parameters
        ----------
        path : str
            Path to .srt file

        Returns
        -------
        subtitle : Transcription
        """

        # load .srt file using pysrt
        subtitles = pysrt.open(path)

        # initial empty transcription
        transcription = Transcription(uri=uri)

        # keep track of end of previous subtitle
        prev_end = TStart

        # loop on each subtitle in chronological order
        for subtitle in subtitles:

            # convert start/end time into seconds
            start = self._timeInSeconds(subtitle.start)
            end = self._timeInSeconds(subtitle.end)

            # connect current subtitle with previous one
            # if there is a gap between them
            if start > prev_end:
                transcription.add_edge(prev_end, start)
            # raise an error in case current subtitle starts
            # before previous subtitle ends
            elif start < prev_end:
                raise ValueError('Non-chronological subtitles')

            # split subtitle in multiple speaker lines (only if needed)
            lines = self._split(subtitle.text)

            # loop on subtitle lines
            for line, start_t, end_t in self._duration(lines, start, end):
                transcription.add_edge(start_t, end_t, subtitle=line)

            prev_end = end

        transcription.add_edge(end, TEnd)

        self._loaded = {(uri, 'subtitle'): transcription}

        return self
Esempio n. 29
0
    def render(self, input_video_fname, input_subt_fname, output_video_fname):
        capture, writer = self._get_video_components(input_video_fname, output_video_fname)
        subts = pysrt.open(input_subt_fname)

        print "total %s frames" % self._frame_count
        for idx in range(self._frame_count):
            ret, frame = capture.read()
            if not ret:
                break
            print "\rframe %d" % idx,
            sys.stdout.flush()
            frame = self._put_subt(idx, frame, subts)
            writer.write(frame)
Esempio n. 30
0
    def _read_dvs(self, dvs_filename):
        """Read a DVS file.
        """
        dvs_text = pysrt.open(dvs_filename, encoding='iso-8859-1')
        dvs_text = [l.strip() for l in dvs_text.text.split('\n')]
        dvs_text = [quote_matches.sub('', l).strip() for l in dvs_text]

        # Cleanup DVS (remove the DVS index and stuff in {})
        for k in range(len(dvs_text)):
            dvs_text[k] = dvs_rep.sub('', dvs_text[k]).strip()
            dvs_text[k] = dvs_cur.sub('', dvs_text[k]).strip()

        return dvs_text
Esempio n. 31
0
import nltk
import json
import pysrt
from nltk.tag.stanford import POSTagger
english_postagger = POSTagger('models/english-bidirectional-distsim.tagger', 'stanford-postagger.jar')
from nltk.stem import WordNetLemmatizer
wnl = WordNetLemmatizer()
from nltk.tokenize import RegexpTokenizer
toker = RegexpTokenizer(r'((?<=[^\w\s])\w(?=[^\w\s])|(\W))+', gaps=True)
from nltk.corpus import stopwords
stop = stopwords.words('english')
subs = pysrt.open('deneme.srt')
ignore = -1
j=0
myObj=[]
tok=[]
f = open('kelimeler', 'wr')
for (i,sub) in enumerate(subs):
   if ignore == i:
     ignore = -1
     continue
   text = sub.text.strip()
   if not text[-1] in ".!?":
      text += " "+subs[i+1].text
      ignore = i+1
   #print english_postagger.tag(text.split())[0][1]
   for j in english_postagger.tag(text.split()):
      #print i
     #print j[0]
     if ((j[0] not in stop) and (j[1] == "NN" or j[1] == "JJ" or j[1] == "VB")):
         start=str(sub.start)	
if os.path.exists(os.path.join(current_path, "mod-et-emo-004.csv")):
    os.remove(os.path.join(current_path, "mod-et-emo-004.csv"))
if len(sentences) == len(emotional_intensity):
    df = pd.DataFrame(
        data={
            'Sentences': sentences,
            'Emotional Intensity': emotional_intensity,
            'Polarity': polarity
        })
    df.to_csv('mod-et-emo-004.csv', sep='\t', index=False)

# ## mod-et-emo-005 ==> Association of the temporary emotional intensity in a video

# In[86]:

subs = pysrt.open(input_subtitle_path)
x = subs[len(subs) - 1]
[hour, minute, sec] = [x.end.hours, x.end.minutes, x.end.seconds]
total_duration = hour * 3600000 + minute * 60000 + sec * 1000

text = ""
for i in range(len(subs)):
    a = subs[i]
    text = text + " " + a.text

words = clean_words(text)
num_words = len(words)
print("Total words: " + str(num_words))
words_per_duration = num_words / total_duration
time_period = int(total_duration / num_period)
print("Time period in milliseconds: " + str(time_period))
Esempio n. 33
0
def main():
    # Load the subtitles
    subs = pysrt.open('/home/juan/Videos/AMOR.es.srt', encoding='iso-8859-1')

    # Start the video capture
    cap = cv2.VideoCapture('/home/juan/Videos/AMOR.mp4')

    cv2.namedWindow('Original')
    cv2.namedWindow('Cropped')

    # Extract number of subtitles
    num_subs = len(subs)
    print('Num subtitles:', num_subs)

    # Extract video metadata
    height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
    width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
    fps = cap.get(cv2.CAP_PROP_FPS)
    print('video resolution:', width, ' x ', height)
    print('video framerate:', fps)

    cv2.waitKey(0)

    for s_idx, sub in enumerate(subs):
        s = "{0:1d}, {1:02d}:{2:02d} to {3:02d}:{4:02d} {5:s}"
        text = cleanhtml(sub.text)
        print(
            s.format(s_idx, sub.start.minutes, sub.start.seconds,
                     sub.end.minutes, sub.end.seconds, text))

    while True:
        # capture next frame
        ret, frame = cap.read()

        if PROCESS_VIDEO:
            # resiz frame for faster processing
            frame = cv2.resize(frame, (0, 0),
                               fx=0.5,
                               fy=0.5,
                               interpolation=cv2.INTER_LINEAR)

            # detect faces and landmarjs
            bounding_boxes, landmarks = detect_faces(frame)

            # if only one face detected
            if bounding_boxes.shape[0] == 1:
                # extract the bounding box
                bb = bounding_boxes[0]
                x1, y1, x2, y2 = int(bb[0]), int(bb[1]), int(bb[2]), int(bb[3])

                # crop the face
                cropped = frame[y1:y2, x1:x2]
                cv2.imshow('Cropped', cropped)

            # draw the bounding box and landmarks on original frame
            frame = show_bboxes(frame, bounding_boxes, landmarks)

        # Display the image
        cv2.imshow('Original', frame)

        # Read keyboard and exit if ESC was pressed
        k = cv2.waitKey(10) & 0xFF
        if k == 27:
            break

    # Release resources
    cap.release()
    cv2.destroyAllWindows()
Esempio n. 34
0
import time
import pysrt
full=str()
subs = pysrt.open("test.srt")
l=len(subs)
for k in range(0,5):
    for i in range((k*l)//5,((k+1)*l//5)):
        full=full+subs[i].text+"\n\n"
print(full)
print(subs.text)
Esempio n. 35
0
def extract_subtitles(filename, text_only=True):
    subtitles = pysrt.open(filename)
    if text_only:
        return [subtitle.text for subtitle in subtitles]
    return subtitles
Esempio n. 36
0
def lin_shift(srt):
    name, ext = os.path.splitext(srt)
    subs = pysrt.open(srt)
    subs.shift(seconds=2 * 60 + 26.452)
    # subs.shift(seconds=t3)
    subs.save(name + 'm' + ext)
Esempio n. 37
0
import pysrt
import sys
import os
import shutil

reload(sys)
sys.setdefaultencoding('utf-8')

#Main Function
if __name__ == '__main__':
    subs = pysrt.open(str(sys.argv[1]), encoding='iso-8859-1')  #input srt file
    src = str(sys.argv[2])  #input source location

    frameRate = 30
    #frame rate of the video

    #get the youtube link
    fileName = str(sys.argv[1]).split('-')
    fileName = fileName[1].split('.')
    fileName = fileName[0]

    for sub in subs:

        #get start and end times of subtitles
        startTime = int(sub.start.hours * 3600 + sub.start.minutes * 60 +
                        sub.start.seconds)
        endTime = int(sub.end.hours * 3600 + sub.end.minutes * 60 +
                      sub.end.seconds)

        #determine start and end frames numbers
        if startTime == 1:
Esempio n. 38
0
import pysrt
import math

#subs1 = pysrt.open('cze.srt', encoding='iso-8859-1')
#subs2 = pysrt.open('eng.srt', encoding='iso-8859-1')
subs1 = pysrt.open('eng.srt', encoding='iso-8859-1')
subs2 = pysrt.open('cze.srt', encoding='iso-8859-1')

OFFSET = 1

for s1 in subs1:
    s1StartTime = s1.start.seconds + s1.start.minutes * 60 + s1.start.hours * 60 * 60
    s1EndTime = s1.end.seconds + s1.end.minutes * 60 + s1.end.hours * 60 * 60

    print s1.text.encode('iso-8859-1'),

    end = False
    for s2 in subs2:
        if end:
            break

        s2StartTime = s2.start.seconds + s2.start.minutes * 60 + s2.start.hours * 60 * 60
        s2EndTime = s2.end.seconds + s2.end.minutes * 60 + s2.end.hours * 60 * 60

        # Zacinaji pobliz startu s1 nejake tiutlky s2?
        #print math.fabs(s1StartTime - s2StartTime)
        if math.fabs(s1StartTime - s2StartTime) <= OFFSET:
            # Pokud ano..vypisuje:
            print '\t------\t', s2.text.encode('iso-8859-1')

            for foo in subs2:
Esempio n. 39
0
def new_audio_trim(chunk):
    chunk_file = chunk['audio_chunk'].split('/')[-1]
    old_chunk_file = chunk['history'][1]['audio_chunk'].split('/')[-1]
    old_subtitle = chunk['history'][1]['subtitle']
    new_subtitle = chunk['subtitle']
    ext = '.' + chunk_file.split('.')[-1]
    old_ext = '.' + old_chunk_file.split('.')[-1]
    old_chunk_file_name = old_chunk_file.split('.')[0]
    chunk_file_name = chunk_file.split('.')[0]

    print('old', old_chunk_file)
    print('new', chunk_file)
    video_id = chunk['VideoTutorial']
    folder_path = os.path.join(settings.MEDIA_ROOT,
                               settings.VIDEO_PROCESSING_ROOT, video_id)
    chunk_directory = os.path.join(folder_path, CHUNKS_DIRECTORY)
    os.chdir(chunk_directory)

    fp = open(CHUNKS_LIST_FILE_NAME, 'r')
    chunk_list = str(fp.read())
    if old_ext == '.webm':
        chunk_list = chunk_list.replace(
            'file ' + "'" + old_chunk_file_name + AUDIO_FILE_EXTENSION + "'",
            'file ' + "'" + chunk_file + "'")

    if old_ext == '.webm' and ext == '.webm':
        chunk_list = chunk_list.replace(
            'file ' + "'" + old_chunk_file_name + AUDIO_FILE_EXTENSION + "'",
            'file ' + "'" + chunk_file_name + AUDIO_FILE_EXTENSION + "'")
    if ext == '.webm':
        chunk_list = chunk_list.replace(
            'file ' + "'" + old_chunk_file + "'",
            'file ' + "'" + chunk_file_name + AUDIO_FILE_EXTENSION + "'")
    else:
        chunk_list = chunk_list.replace('file ' + "'" + old_chunk_file + "'",
                                        'file ' + "'" + chunk_file + "'")
    print(chunk_list)
    fp.close()
    fp = open(CHUNKS_LIST_FILE_NAME, 'w')
    fp.write(chunk_list)
    fp.close()

    # modify subtitle file
    subs = pysrt.open('../' + SUBTITLE_FILE_NAME + SUBTITLE_FILE_EXTENSION,
                      encoding='utf-8')
    old_text = subs[chunk['chunk_no']]
    old_text.text = new_subtitle
    subs.save('../' + SUBTITLE_FILE_NAME + SUBTITLE_FILE_EXTENSION,
              encoding='utf-8')

    start_time = chunk['start_time']
    end_time = chunk['end_time']
    time_format = '%H:%M:%S'

    VideoTutorial.objects.filter(pk=video_id).update(status='in_queue')

    diff = datetime.strptime(end_time, time_format) - datetime.strptime(
        start_time, time_format)
    if (ext == '.webm'):
        # webm support
        print('webm')
        os.system('ffmpeg -i ' + chunk_file + ' -vn -c:a libmp3lame -ar ' +
                  AUDIO_SAMPLE_RATE + ' -ab ' + AUDIO_BIT_RATE + ' ' +
                  chunk_file_name + AUDIO_FILE_EXTENSION)
        chunk_file = chunk_file_name + AUDIO_FILE_EXTENSION
        # obj = VideoChunk.objects.get(VideoTutorial=video_id, chunk_no=chunk['chunk_no'])
        # obj.audio_chunk = os.path.join(settings.VIDEO_PROCESSING_ROOT, video_id, CHUNKS_DIRECTORY,
        #                                chunk_file_name + AUDIO_FILE_EXTENSION)
        # obj.save()

    os.rename(chunk_file, 'temp' + AUDIO_FILE_EXTENSION)
    os.system('ffmpeg -i temp' + AUDIO_FILE_EXTENSION + ' -ab ' +
              AUDIO_BIT_RATE + ' -ar ' + AUDIO_SAMPLE_RATE +
              ' -c copy -map_metadata -1 temp1' + AUDIO_FILE_EXTENSION)
    # getting the length of audio
    audio_length_format = '%H:%M:%S.%f'
    audio_length_str = str(os.popen(
        "ffprobe -v error -sexagesimal -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 temp1" + AUDIO_FILE_EXTENSION) \
                           .read())
    audio_length_str = audio_length_str.rstrip()
    audio_start_time = start_time + '.000000'
    audio_end_time = end_time + '.000000'
    audio_len = datetime.strptime(audio_length_str,
                                  audio_length_format) - datetime.strptime(
                                      "00:00:00.000000", audio_length_format)
    audio_diff = datetime.strptime(audio_end_time,
                                   audio_length_format) - datetime.strptime(
                                       audio_start_time, audio_length_format)
    if audio_len < audio_diff:
        print('less')
        # add some silence
        abs_diff = str(abs(audio_diff - audio_len))
        os.system("ffmpeg -y -f lavfi -i anullsrc=sample_rate=" +
                  AUDIO_SAMPLE_RATE + " -ab " + AUDIO_BIT_RATE + " -t " +
                  abs_diff + " silence" + AUDIO_FILE_EXTENSION)
        os.system('ffmpeg -y -i "concat:temp1' + AUDIO_FILE_EXTENSION +
                  '|silence' + AUDIO_FILE_EXTENSION + '" -acodec copy temp2' +
                  AUDIO_FILE_EXTENSION)
        command = str("ffmpeg -y -i temp2" + AUDIO_FILE_EXTENSION +
                      " -ss 00:00:00.000 " + " -to " + str(diff) +
                      " -c copy " + chunk_file)

    else:
        print('more')
        command = str("ffmpeg -y -i temp1" + AUDIO_FILE_EXTENSION +
                      " -ss 00:00:00.000 " + " -to " + str(diff) +
                      " -c copy " + chunk_file)
    os.system(command)
    os.remove('temp' + AUDIO_FILE_EXTENSION)
    os.remove('temp1' + AUDIO_FILE_EXTENSION)
    if os.path.exists('temp2' + AUDIO_FILE_EXTENSION):
        os.remove('temp2' + AUDIO_FILE_EXTENSION)

    compile_all_chunks(video_id)
Esempio n. 40
0
def process_video(video_id):
    """
    this function will break the uploaded video into
    chunks and will store audio separately
    """
    folder_path = os.path.join(settings.MEDIA_ROOT,
                               settings.VIDEO_PROCESSING_ROOT, video_id)
    os.chdir(folder_path)
    # convert to mp4
    os.system('ffmpeg -y -i ' + VIDEO_FILE_NAME + INCOMING_VIDEO_EXTENSION +
              ' -max_muxing_queue_size 1024 -c:v libx264 -c:a libmp3lame ' +
              ' -ab ' + AUDIO_BIT_RATE + ' -ar ' + AUDIO_SAMPLE_RATE + ' ' +
              VIDEO_FILE_NAME + VIDEO_FILE_EXTENSION)
    # extract video
    os.system('ffmpeg -y -i ' + VIDEO_FILE_NAME + VIDEO_FILE_EXTENSION +
              ' -c copy -an ' + VIDEO_WITHOUT_AUDIO_FILE_NAME +
              VIDEO_FILE_EXTENSION)
    # extract audio
    os.system('ffmpeg -y -i ' + VIDEO_FILE_NAME + VIDEO_FILE_EXTENSION +
              ' -ab ' + AUDIO_BIT_RATE + ' -ar ' + AUDIO_SAMPLE_RATE +
              ' -vn -c copy ' + AUDIO_FILE_NAME + AUDIO_FILE_EXTENSION)
    chunk_directory = os.path.join(folder_path, CHUNKS_DIRECTORY)
    os.mkdir(chunk_directory)
    fp = open(SUBTITLE_FILE_NAME + SUBTITLE_FILE_EXTENSION, 'r')
    subtitle_text = str(fp.read())
    x = re.sub(r'[0-9][0-9]:[0-5][0-9]:[0-5][0-9](?!,)', repl, subtitle_text)
    fp.close()
    fp = open(SUBTITLE_FILE_NAME + SUBTITLE_FILE_EXTENSION, 'w')
    fp.write(x)
    fp.close()
    compile_video_list = open(CHUNKS_DIRECTORY + '/' + CHUNKS_LIST_FILE_NAME,
                              'w+')

    subs = pysrt.open(SUBTITLE_FILE_NAME + SUBTITLE_FILE_EXTENSION,
                      encoding='utf-8')
    VideoTutorial.objects.filter(pk=video_id).update(total_chunks=len(subs))

    for i in range(len(subs)):
        sub_text = str(subs[i].text)
        start_time = str(subs[i].start).replace(',', '.')
        end_time = str(subs[i].end).replace(',', '.')
        nos_audio_file_name = chunk_directory + "/" + 'h_' + str(
            i) + AUDIO_FILE_EXTENSION

        # for the first video without subtitle
        if (i == 0) and (start_time != '00:00:00.000'):
            command = str("ffmpeg -i " + AUDIO_FILE_NAME +
                          AUDIO_FILE_EXTENSION + " -ss 00:00:00.000 " +
                          " -to " + start_time + " -c copy " +
                          nos_audio_file_name)
            os.system(command)
            compile_video_list.write("file '" + 'h_' + str(i) +
                                     AUDIO_FILE_EXTENSION + "'\n")

        if i != 0:
            nos_start_time = str(subs[i - 1].end).replace(',', '.')
            nos_end_time = str(subs[i].start).replace(',', '.')
            if nos_start_time != nos_end_time:
                command = str("ffmpeg -i " + AUDIO_FILE_NAME +
                              AUDIO_FILE_EXTENSION + " -ss " + nos_start_time +
                              " -to " + nos_end_time + " -c copy " +
                              nos_audio_file_name)
                os.system(command)
                compile_video_list.write("file '" + 'h_' + str(i) +
                                         AUDIO_FILE_EXTENSION + "'\n")

        audio_file_name = chunk_directory + "/" + str(i) + AUDIO_FILE_EXTENSION
        command = str("ffmpeg -i " + AUDIO_FILE_NAME + AUDIO_FILE_EXTENSION +
                      " -ss " + start_time + " -to " + end_time + " -c copy " +
                      audio_file_name)
        os.system(command)
        compile_video_list.write("file '" + str(i) + AUDIO_FILE_EXTENSION +
                                 "'\n")

        VideoChunk.objects.create(
            chunk_no=i,
            VideoTutorial=VideoTutorial.objects.get(id=video_id),
            audio_chunk=os.path.join(settings.VIDEO_PROCESSING_ROOT, video_id,
                                     CHUNKS_DIRECTORY,
                                     str(i) + AUDIO_FILE_EXTENSION),
            start_time=start_time,
            end_time=end_time,
            subtitle=sub_text.encode())

        if i == len(subs) - 1:
            nos_audio_file_name = chunk_directory + "/" + 'h_' + str(
                i + 1) + AUDIO_FILE_EXTENSION
            command = str("ffmpeg -i " + AUDIO_FILE_NAME +
                          AUDIO_FILE_EXTENSION + " -ss " + end_time +
                          " -c copy " + nos_audio_file_name)
            os.system(command)
            compile_video_list.write("file '" + 'h_' + str(i + 1) +
                                     AUDIO_FILE_EXTENSION + "'\n")

    compile_video_list.close()

    compile_all_chunks(video_id)
Esempio n. 41
0
def get_movie_data(movies_list):
    # INIT OBJECT

    for i in movies_list:

        class movie(object):
            def __init__(self):
                self.title = ""
                self.year = ""
                self.rating = ""
                self.subtitles = ""

            def __repr__(self):
                return str(self)

        # h2 = i.find('div', attrs = {'class':'article_movie_title'})
        # title = h2.a.text.strip()
        # year = h2.find('span', attrs = {'class':"subtle start-year"}).text.strip()

        # actors = []
        # actors_div = i.find('div', attrs = {'class':'info cast'}).findAll('a')
        # for j in actors_div:
        #     actor = j.text
        #     actors.append(actor)
        # separator = ', '
        # actors = separator.join(actors)

        # director = i.find('div', attrs = {'class':"info director"}).a.text.strip()

        movie.title = i
        # movie.year = '1991' #year.replace('(','').replace(')','')
        # movie.rating = rating.replace('%','')
        # movie.actors = actors
        # movie.director = director

        ## SCRAPE AND LOAD SUBTITLES
        url = "http://www.yifysubtitles.com/search?q="
        movie_name = movie.title
        movie_fix = movie_name.lower().replace("½", " 1/2").replace(
            "é", "e").replace(" ", "+")

        # connect to url
        movie_url = url + movie_fix

        scheme, netloc, path, query, fragment = parse.urlsplit(movie_url)
        path = parse.quote(path)
        movie_url = parse.urlunsplit((scheme, netloc, path, query, fragment))
        print(movie_url)

        try:
            source = urllib.request.urlopen(movie_url).read()
            soup_movie = BeautifulSoup(source,
                                       "html.parser",
                                       from_encoding="utf-8")
        except urllib.error.HTTPError:
            print('MISSING SEARCH', movie_name)
            pass
        # Searches through a table of movies
        if soup_movie.find("h3", string=movie.title):
            link = soup_movie.find(
                "h3", string=movie.title).find_parent("a").get("href")
            #print(link)
            parse_obj = urlparse(movie_url)
            url = parse_obj.scheme + "://" + parse_obj.netloc
            sub_url = url + link

            try:
                sub_source = urllib.request.urlopen(sub_url).read()
                soup_sub = BeautifulSoup(sub_source,
                                         "html.parser",
                                         from_encoding="utf-8")

            except urllib.error.HTTPError:
                print('MISSING PAGE', movie_name)
                pass

            # Searches through a list of subtitles
            if soup_sub.find("span", string="English"):
                yify = "https://www.yifysubtitles.com/"
                year = soup_sub.find('div',
                                     attrs={
                                         'class': "circle",
                                         'data-info': "year"
                                     }).get("data-text")
                rating = soup_sub.find('div',
                                       attrs={
                                           'class': "circle",
                                           'data-info': "Tomato"
                                       }).get("data-text")
                link_sub = soup_sub.find(
                    "span", string="English").find_parent("tr").find(
                        "a", {
                            "class": "subtitle-download"
                        }).get("href")
                link_sub = yify + link_sub
                #print(link_sub)
                sub_final = urllib.request.urlopen(link_sub).read()
                soup_final = BeautifulSoup(sub_final,
                                           "html.parser",
                                           from_encoding="utf-8")

                # Scrapes the subtitle url
                if soup_final.find("a",
                                   {"class": "btn-icon download-subtitle"}):
                    link_final = soup_final.find(
                        "a", {
                            "class": "btn-icon download-subtitle"
                        }).get("href")
                    print(link_final)

                    current_directory = os.getcwd()
                    zip_directory = os.path.join(current_directory, r'zip')
                    if not os.path.exists(zip_directory):
                        os.makedirs(zip_directory)
                    urllib.request.urlretrieve(
                        link_final, '{}/{}.zip'.format(zip_directory,
                                                       movie.title))
                    zip_file = '{}/{}.zip'.format(zip_directory, movie.title)
                    dest = os.path.join(current_directory, r'subs')
                    if not os.path.exists(dest):
                        os.makedirs(dest)
                    f = zipfile.ZipFile(zip_file)

                    for file in f.namelist():
                        if file.endswith('.srt'):
                            print('Extracting: ' + file)
                            try:
                                f.extract(file, path='subs')
                                subs = pysrt.open(os.path.join(dest, file),
                                                  encoding='iso-8859-1')
                                file_name = '{}/{}.txt'.format(
                                    dest, movie.title)
                                try:
                                    os.remove(file_name)
                                except:
                                    print("Error while deleting file ",
                                          file_name)

                                if subs:
                                    for sub in subs:
                                        with open(file_name, 'a') as f:
                                            #f.write("1\n")
                                            #f.write("{0} --> {1}\n".format(start_new, end_new))
                                            f.write(sub.text)
                                            #movie.subtitles = sub_text
                                    with open(file_name) as fp:
                                        subtitles = fp.read()
                                else:
                                    print("Error while writing file ", file)
                                    subtitles = "no link"
                            except:
                                print("Error while extracting file ", file)
                                subtitles = "no link"
                        else:
                            subtitles = "no link"
                else:
                    subtitles = "no link"
            else:
                subtitles = "no link"
        else:
            subtitles = "no link"

        movie.subtitles = subtitles
        if year is None:
            movie.year = "N/A"
        else:
            movie.year = year
        if rating is None:
            movie.rating = "N/A"
        else:
            movie.rating = rating

        print(movie.title, movie.year, movie.rating)

        movies.append(movie)
Esempio n. 42
0
# Import everything needed to edit video clips
from moviepy.editor import *
import pysrt
from moviepy.editor import concatenate_audioclips
from tts_it import sub_to_audio
from speed import speed_adjust

# Load your movie
# Give proper path to your movie
videoclip = VideoFileClip("single_scene.mp4")
audioclip = videoclip.audio

#importing subtitles
#provide full path to subtitle file
subs = pysrt.open('sub_1.srt')

# initializing some parameters
last_e = '00:00:00.00'
final_clip = audioclip.subclip(0, 0)


def time_conv(_sub):
    ''' convert SubRipTime to usable format '''
    last_e_h, last_e_m, last_e_s, last_e_ms = _sub
    last_e_ms = last_e_ms // 10
    s = str(last_e_h) + ':' + str(last_e_m) + ':' + str(last_e_s) + '.' + str(
        last_e_ms)
    return s


for sub in subs:
Esempio n. 43
0
def process_video_with_srt(video_file):
    file_name, file_extension = os.path.splitext(video_file)
    srt_file_name = file_name + '_correct.srt'

    with open(srt_file_name, 'r',
              encoding=get_file_encode(srt_file_name)) as srt_file:
        # 字幕列表格式
        # 0 = {str}
        # '11\n'
        # 1 = {str}
        # '00:00:21,770 --> 00:00:23,270\n'
        # 2 = {str}
        # '是我\n'
        # 3 = {str}
        # 'Hey, it’s me.\n'

        if os.path.isdir(file_name):
            shutil.rmtree(file_name, ignore_errors=True)
        os.makedirs(file_name)

        video_info_cmd = 'ffprobe -v quiet -print_format json -show_format -show_streams "{}"'.format(
            video_file)
        video_duration = float(
            json.loads(run_command(video_info_cmd))['format']['duration'])
        encode = get_file_encode(srt_file_name)
        subtitle_list = pysrt.open(srt_file_name, encoding=encode)
        srt_info_duration = (subtitle_list[-1].end -
                             subtitle_list[0].start).to_time()
        srt_duration = srt_info_duration.hour * 3600 + srt_info_duration.minute * 60 + srt_info_duration.second
        if (video_duration > srt_duration + 5000):
            print('视频长度远大于字幕最大长度,可能不匹配')
            return

        for subtitle in subtitle_list:
            # 长度小于3秒的 不带字幕的 前1分钟内的 不切
            if subtitle.duration.seconds < 3 or len(
                    subtitle.text_without_tags
            ) == 0 or subtitle.start.minutes < 1:
                continue
            start_time = '{}'.format(subtitle.start).split(',')[0]
            # 加上1秒的缓冲 可能不够
            subtitle.end.seconds += 1
            end_time = '{}'.format(subtitle.end).split(',')[0]

            # 根据是否有中文判断是否是翻译
            subtitle_lines = subtitle.text_without_tags.split('\n')
            subtitle_text_chn = ''
            subtitle_text_eng = ''
            for line in subtitle_lines:
                if check_contain_chinese(line):
                    if mafan_text.is_traditional(line):
                        subtitle_text_chn += mafan_text.simplify(line.strip())
                    else:
                        subtitle_text_chn += line.strip()
                else:
                    subtitle_text_eng += line.strip()

            # 没翻译 或者没原文 不切
            if len(subtitle_text_eng) < 4 or len(subtitle_text_chn) == 0:
                continue

            # if subtitle_text_eng.startswith('Then I got really freaked out, and that'):
            #     print(subtitle_text_eng)
            # else:
            #     continue

            # 如果要保存 必须去掉特殊字符
            subtitle_text_eng = validate_file_name(subtitle_text_eng)

            if os.name == 'nt':
                subtext = file_name + '\\' + subtitle_text_eng + '.mp4'
            else:
                subtext = file_name + '/' + subtitle_text_eng + '.mp4'

            # 如果有同名的文件 以最后一个为准
            if os.path.isfile(subtext):
                os.remove(subtext)

            #https://stackoverflow.com/questions/20847674/ffmpeg-libx264-height-not-divisible-by-2
            cmd = 'ffmpeg -i "{}" -ss {} -to {} -vf scale=560:-2 -c:v libx264 -c:a aac -crf 30 -ac 1 -preset veryslow "{}"'.format(
                video_file, start_time, end_time, subtext)

            print(cmd)
            rst = run_command(cmd)
Esempio n. 44
0
def empty(update: Update, context: CallbackContext):
    file = pysrt.open(context.chat_data['file'], encoding='UTF-8')
    file[context.chat_data['line']].text = ''
    file.save(context.chat_data['file'], encoding='UTF-8')
    send.next_line(update, context)
## there is a file located below: 
##     https://storage.googleapis.com/qst-datasets/subtitles/Shrek-2001.srt
## there is also some started code below
## calculate the sentiment over the course of the movie script (Shrek)
## plot the sentiment arc over the movie
##

# 0. get the file - the file in the browser will auto download
#    just make sure you have the file in your working directory

# or if on colab
! wget https://storage.googleapis.com/qst-datasets/subtitles/Shrek-2001.srt

# 1. get the file and parse
import pysrt
subs = pysrt.open('Shrek-2001.srt', encoding='iso-8859-1')

##################################### Quick example 
##################################### Key Words in Context - Concordance
###
### powerful tool to look at a set of text (full corpus) and look for
### words before/after
###
### helpful for eda, look for patterns to help support data annotation, etc.


# just in case
# nltk.download('punkt')

# get the data
# SQL = "SELECT * FROM `questrom.datasets.topics`"
Esempio n. 46
0
import pysrt
from pydub import AudioSegment

audio_name = 'vachtuongcu.mp3'
sub_name = 'vachtuongcu.srt'
audio_outdir = 'output'
csv_output = 'output.csv'

song = AudioSegment.from_file(audio_name)
subs = pysrt.open(sub_name, encoding='utf-8')

# Define lambda function convert time to miliseconds
time_to_ms = lambda x: (x.hours * 3600 + x.minutes * 60 + x.seconds
                        ) * 1000 + x.milliseconds

# Extract data
with open(csv_output, 'w') as fd:
    for sub in subs:
        # Get start time, end time in miliseconds
        start_ms = time_to_ms(sub.start)
        end_ms = time_to_ms(sub.end)
        # Audio extracted file name
        audio_extract_name = '{}/{}_{}_{}.wav'.format(audio_outdir, audio_name,
                                                      start_ms, end_ms)
        text = str(sub.text.encode('utf-8'))
        # Extract file
        extract = song[start_ms:end_ms]
        # Saving
        extract.export(audio_extract_name, format="wav")
        # Write to csv file
        fd.write('{}|{}\n'.format(audio_extract_name, text))
Esempio n. 47
0
        srt_original = arguments[i + 1]
    elif arguments[i] == '-out':
        srt_target = arguments[i + 1]
    elif arguments[i] == '-source':
        source_lang = arguments[i + 1]
    elif arguments[i] == '-target':
        target_lang = arguments[i + 1]

#for testing purposes gave the variables values
srt_original = 'Dunkirk.2017.720p.BluRay.x264-SPARKS.srt'
srt_target = 'fullTranslationInSpanish.srt'
source_lang = 'EN'
target_lang = 'ES'

import pysrt
subs = pysrt.open(srt_original)  #holds the srt inpur file

import deepl

words_per_screen = [
]  #holds number of words on that frame of the srt file before translation
for i in range(len(
        subs)):  # fills words per screen with the number of words per frame
    words = subs[i].text.split(' ')
    for word in range(len(words)):
        words[word] = words[word].replace('\n', ' ')
        split = words[word].split(' ')
        if len(split) > 1:
            words[word] = split[0]
            words.insert(word + 1, split[1])
    words_per_screen.append(len(words))
Esempio n. 48
0
 def parse(self, file_name, file_encoding):
     self._sub_entries = pysrt.open(file_name, file_encoding)
Esempio n. 49
0
import pysrt,simplekml,csv

video_path = '/home/mayank/Documents/Skylark_Drones_Tasks/software_dev/videos/DJI_0301.SRT'	# video_path(SRT) and its name
video = pysrt.open(video_path)	

kml=simplekml.Kml()

for frame in video:
	lat_lon = frame.text.split(',')					# seperating time of frame, latitude and longitude
	kml.newpoint(name = str(frame.start), coords = [(lat_lon[0],lat_lon[1])])

kml.save('drone.kml')
Esempio n. 50
0
from docx import Document
from docx.shared import Inches
import pysrt

in_file = 'motocultor.srt'
doc_name = in_file.split('.')[0]
out_file = in_file.replace('.srt', '2.docx')

subs = pysrt.open(in_file, encoding='ansi')

document = Document()

document.add_paragraph(doc_name.upper() + '.')
document.add_paragraph('(Tiempo de duración: )\n')

document.add_picture('monty-truth.jpg', width=Inches(1.25))

for sub in subs:
    print(sub.start)
    print(sub.text)
    document.add_paragraph(str(sub.start))
    document.add_paragraph(sub.text + '\n')

document.save(out_file)
	        font = cv2.FONT_HERSHEY_SIMPLEX

	        overlay = image.copy()

	        cv2.rectangle(overlay, (1, height-15-11), (width-1, height-1), (255,0,0), -1)

	        opacity = 0.4

	        cv2.addWeighted(overlay, opacity, image, 1 - opacity, 0, image)

	        cv2.putText(image,text,(10,height-10), font, 0.4, (255,255,255),1)
	        cv2.imwrite('frame%04d.jpg' % (ms/1000), image)



if __name__ == '__main__':
	   parser = argparse.ArgumentParser()

	   parser.add_argument('video', help = 'path to video file')
	   parser.add_argument('sub', help = 'path to sub file')

	   args = parser.parse_args()
	   subs = pysrt.open(args.sub)
	   videofile = args.video

	   for i in xrange(0, len(subs)):
	           seconds_start = (subs[i].start.seconds) + (subs[i].start.minutes * 60) + (subs[i].start.hours * 60 * 60)
	           seconds_end = (subs[i].start.seconds) + (subs[i].start.minutes * 60) + (subs[i].start.hours * 60 * 60)

	           ms = mid(seconds_start*1000,seconds_end*1000)
	           save_new_frame(videofile, ms, str(subs[i].text))       	
from googletrans import Translator
translator = Translator()
f1 = open('friends.srt', "r", encoding="utf-8")
f2 = open('hindi2.srt', "a", encoding="utf-8")

for line in f1:
    tr = translator.translate(line, dest='hi')
    print(tr.text)
    f2.write(tr.text + "\n")

f1.close()
f2.close()

import pysrt
subs = pysrt.open('hindi.srt')

from pydub import AudioSegment
from pydub.playback import play
from gtts import gTTS
import os


def speed_swifter(sound, speed):
    return sound._spawn(
        sound.raw_data,
        overrides={"frame_rate": int(sound.frame_rate * speed)})


startmilli = 0
s = AudioSegment.silent(duration=0)
for sub in subs:
Esempio n. 53
0
#!//Users/tkirke/anaconda/bin/python
import pysrt, sys, os

fil = sys.argv[1]
try:
    subs = pysrt.open(fil, encoding ='utf-8')
except:
    subs = pysrt.open(fil, encoding ='iso-8859-1')

size = len(subs)
count = 0
for i in subs:
    s = subs[count]
    count = count+1
    t = (44100*(60*s.start.minutes + s.start.seconds + 0.001*s.start.milliseconds))
    print str(t)+"\t"+s.text
Esempio n. 54
0
def read(srtfile):
    """Read subtitle"""
    return pysrt.open(srtfile)
Esempio n. 55
0
  def CreateCleanSubAndMuteList(self, cleanSubsFileSpec=None):
    subFileParts = os.path.splitext(self.inputSubsFileSpec)
    if cleanSubsFileSpec is not None:
      self.cleanSubsFileSpec = cleanSubsFileSpec
      subFileParts = os.path.splitext(self.cleanSubsFileSpec)
      self.cleanSubsNotModFileSpec = subFileParts[0] + "_all_not_cleaned" + subFileParts[1]
    else:
      #self.cleanSubsFileSpec = subFileParts[0] + "_clean" + subFileParts[1]
      subFileFirstParts = os.path.splitext(subFileParts[0])
      self.cleanSubsFileSpec = subFileFirstParts[0] + ".clean" + subFileFirstParts[1] + ".forced" + subFileParts[1]
      #self.cleanSubsNotModFileSpec = subFileFirstParts[0] + ".all_not_cleaned" + subFileFirstParts[1] + subFileParts[1]
      self.cleanSubsNotModFileSpec = subFileFirstParts[0] + '.clean' + subFileFirstParts[1] + subFileParts[1]
      if os.path.isfile(self.inputSubsFileSpec):
        shutil.copyfile(self.inputSubsFileSpec, subFileFirstParts[0] + '.orig' + subFileFirstParts[1] + subFileParts[1])
            
    # remove brackets that interfere with ffmpeg subtitles filter
    self.cleanSubsFileSpec = self.cleanSubsFileSpec.translate({ord(x): '' for x in ['[',']']})

    lines = []

    with open(self.swearsFileSpec) as f:
      lines = [line.rstrip('\n') for line in f]

    for line in lines:
      lineMap = line.split("|")
      if len(lineMap) > 1:
        self.swearsMap[lineMap[0]] = lineMap[1]
      else:
        self.swearsMap[lineMap[0]] = "*****"

    replacer = re.compile(r'\b(' + '|'.join(self.swearsMap.keys()) + r')\b', re.IGNORECASE)


    blob = open(self.inputSubsFileSpec, 'rb').read()
    m = magic.open(magic.MAGIC_MIME_ENCODING)
    m.load()
    encoding = m.buffer(blob)

    subs = pysrt.open(self.inputSubsFileSpec, encoding=encoding)
    newSubs = pysrt.SubRipFile()
    newSubsNotMod = pysrt.SubRipFile()
    for sub in subs:
      newText = replacer.sub(lambda x: self.swearsMap[x.group()], sub.text)
      #print("old: "+sub.text+", new: "+newText)
      if (newText != sub.text):
        newSub = sub
        newSub.text = newText
        newSubs.append(newSub)
      #else:
      newSubsNotMod.append(sub)
    newSubs.save(self.cleanSubsFileSpec)
    newSubsNotMod.save(self.cleanSubsNotModFileSpec)

    newLines = []
    for sub in newSubs:
      newLines.append([sub.start.to_time(), sub.end.to_time()])

    self.muteTimeList = []
    for timePair in newLines:
      lineStart = (timePair[0].hour * 60.0 * 60.0) + (timePair[0].minute * 60.0) + timePair[0].second + (timePair[0].microsecond / 1000000.0)
      lineEnd = (timePair[1].hour * 60.0 * 60.0) + (timePair[1].minute * 60.0) + timePair[1].second + (timePair[1].microsecond / 1000000.0)
      self.muteTimeList.append("volume=enable='between(t," + format(lineStart, '.3f') + "," + format(lineEnd, '.3f') + ")':volume=0")
Esempio n. 56
0
def makeGif(source, sub_index, rand=False, no_quote=False, custom_subtitle=""):
    config = ConfigParser.ConfigParser()
    config.read("config.cfg")

    config.sections()

    vlc_path = config.get("general", "vlc_path")

    video_path = config.get("general", "ep" + str(source) + "_path")
    screencap_path = os.path.join(os.path.dirname(__file__), "screencaps")

    # delete the contents of the screencap path
    file_list = os.listdir(screencap_path)
    for file_name in file_list:
        os.remove(os.path.join(screencap_path, file_name))

    # read in the quotes for the selected movie
    subs = pysrt.open(sub_files[source])

    if rand:
        sub_index = random.randint(0, len(subs) - 1)

    if no_quote:
        start = (3600 * subs[sub_index].end.hours) + (
            60 * subs[sub_index].end.minutes) + subs[sub_index].end.seconds + (
                0.001 * subs[sub_index].end.milliseconds)
        end = (3600 * subs[sub_index + 1].start.hours) + (
            60 * subs[sub_index +
                      1].start.minutes) + subs[sub_index + 1].start.seconds + (
                          0.001 * subs[sub_index + 1].start.milliseconds)
    else:
        start = (3600 * subs[sub_index].start.hours) + (
            60 *
            subs[sub_index].start.minutes) + subs[sub_index].start.seconds + (
                0.001 * subs[sub_index].start.milliseconds)
        end = (3600 * subs[sub_index].end.hours) + (
            60 * subs[sub_index].end.minutes) + subs[sub_index].end.seconds + (
                0.001 * subs[sub_index].end.milliseconds)
        text = striptags(subs[sub_index].text).split("\n")

    if len(custom_subtitle) > 0:
        text = [custom_subtitle]

    # tell vlc to go get images for gifs
    cmd = " ".join([
        '"{vlc_path}"', '-Idummy', '--video-filter', 'scene', '-V', 'dummy',
        '--no-audio', '--scene-height=256', '--scene-width=512',
        '--scene-format=png', '--scene-ratio=1', '--start-time={start}',
        '--stop-time={end}', '--scene-prefix=thumb',
        '--scene-path="{screencap_path}"', '"{video_path}"', 'vlc://quit'
    ]).format(
        **{
            "vlc_path": vlc_path,
            "start": start,
            "end": end,
            "screencap_path": screencap_path,
            "video_path": video_path
        })
    os.popen(cmd)

    file_names = sorted((fn for fn in os.listdir(screencap_path)))
    images = []

    font = ImageFont.truetype("fonts/DejaVuSansCondensed-BoldOblique.ttf", 16)

    # remove the first image from the list
    file_names.pop(0)

    for f in file_names:
        try:
            image = Image.open(os.path.join(screencap_path, f))
            draw = ImageDraw.Draw(image)

            try:
                image_size
            except NameError:
                image_size = image.size

            # deal with multi-line quotes
            try:
                if len(text) == 2:
                    # at most 2?
                    text_size = font.getsize(text[0])
                    x = (image_size[0] / 2) - (text_size[0] / 2)
                    y = image_size[1] - (2 * text_size[1]) - 5  # padding
                    drawText(draw, x, y, text[0], font)

                    text_size = font.getsize(text[1])
                    x = (image_size[0] / 2) - (text_size[0] / 2)
                    y += text_size[1]
                    drawText(draw, x, y, text[1], font)
                else:
                    text_size = font.getsize(text[0])
                    x = (image_size[0] / 2) - (text_size[0] / 2)
                    y = image_size[1] - text_size[1] - 5  # padding
                    drawText(draw, x, y, text[0], font)
            except NameError:
                pass
                # do nothing.

            # if not all black?
            if image.getbbox():
                # add it to the array
                images.append(array(image))
                print 'image appended.'
            else:
                print 'all black frame found.'
        except IOError:
            print 'empty frame found.'

    filename = "star_wars.gif"

    # create a f****n' gif
    print "generating gif..."
    writeGif(filename, images, nq=10, dither=True)

    if rand:
        try:
            return text
        except:
            return []
Esempio n. 57
0
def test():
    text = ''
    for srt in glob.glob("youtube-dl-texts/*.srt"):
        tmp = pysrt.open(srt)
        text += tmp.text
    return text.replace('\n', ' ')
Esempio n. 58
0
import matplotlib.pyplot as plt
import scipy
from swda_time import CorpusReader

from helpers import changetime, plottrans

#################
# SUBTITLES
#################

# Read in all subtitles:
path = '../Subtitles/'
allsubs = {}
for filename in os.listdir(path):
    filename = os.path.join(path, filename)
    subs = pysrt.open(filename, encoding='iso-8859-1')
    subdict = {}
    i = 0
    for sub in subs:
        if not ( sub.text.startswith('(') and sub.text.endswith(')')) or not ( sub.text.startswith('[') and sub.text.endswith(']')):
            start = changetime(sub.start)
            end = changetime(sub.end)
            if sub.text.endswith('...'):
                laststart = changetime(sub.start)
            elif sub.text.startswith('...'):
                times = (laststart, end)
                subdict[i] = times
                i += 1
            #give the same timestamp if text is said directly after eachother
            elif sub.text.startswith('-'):
                times1 = (start, end)
Esempio n. 59
0
                print 'here'
                pass

        self.slidend = self.start

        self.w = Scale(self.root,
                       from_=0,
                       to=self.slidend / 1000,
                       length=900,
                       orient=HORIZONTAL)
        self.w.pack()

    def updateText(self, val, verbose=""):
        if verbose:
            print(verbose)
        self.sub_var.set(val)

    def update(self, start, duration, text):
        self.updateText(text, verbose="%i (%i): %s" % (start, duration, text))

if __name__ == "__main__":
    filename = r"C:\Users\admin\Desktop\Python-files\Deskinfo\eternal-loveSUBS\Eternal.Love.E14.srt"
    print('Starting %s' % filename)

    filename = r"C:\Users\admin\Desktop\Python-files\Deskinfo\eternal-loveSUBS\Eternal.Love.E14.srt"
    subs = pysrt.open(filename)

    root = tk.Tk()
    app = Application(root=root, subs=subs)
    app.mainloop()
Esempio n. 60
0
def load_srt(path: pathlib.Path):
    return pysrt.open(path)