



'''simple docstring'''



import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_lowercase       :						Union[str, Any]						=logging.get_logger(__name__)


_lowercase       :						Any						={"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt"""}

# See all MVP models at https://huggingface.co/models?filter=mvp
_lowercase       :						int						={
    """vocab_file""": {
        """RUCAIBox/mvp""": """https://huggingface.co/RUCAIBox/mvp/resolve/main/vocab.json""",
    },
    """added_tokens.json""": {
        """RUCAIBox/mvp""": """https://huggingface.co/RUCAIBox/mvp/resolve/main/added_tokens.json""",
    },
    """merges_file""": {
        """RUCAIBox/mvp""": """https://huggingface.co/RUCAIBox/mvp/resolve/main/merges.txt""",
    },
}

_lowercase       :						Dict						={
    """RUCAIBox/mvp""": 1024,
}


@lru_cache()
def 							__UpperCAmelCase				(				)		->						Optional[int]:
				snake_case__      :   Optional[int]      =    (
				    list(range(ord('''!'''			)   ,				ord('''~'''			) + 1			)			) + list(range(ord('''¡'''			)   ,				ord('''¬'''			) + 1			)			) + list(range(ord('''®'''			)   ,				ord('''ÿ'''			) + 1			)			)
				)
				snake_case__      :   Optional[int]      =    bs[:]
				snake_case__      :   List[str]      =    0
				for b in range(2**8			):
								if b not in bs:
												bs.append(UpperCamelCase_			)
												cs.append(2**8 + n			)
												n += 1
				snake_case__      :   List[str]      =    [chr(UpperCamelCase_			) for n in cs]
				return dict(zip(UpperCamelCase_   ,				UpperCamelCase_			)			)


def 							__UpperCAmelCase				(				UpperCamelCase__				:Tuple			)		->						Tuple:
				snake_case__      :   Tuple      =    set()
				snake_case__      :   Optional[Any]      =    word[0]
				for char in word[1:]:
								pairs.add((prev_char, char)			)
								snake_case__      :   Dict      =    char
				return pairs






class 			_SCREAMING_SNAKE_CASE				(__lowercase      ):
			A__								=  VOCAB_FILES_NAMES
			A__								=  PRETRAINED_VOCAB_FILES_MAP
			A__								=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			A__								=  ['''input_ids''', '''attention_mask''']



			def __init__(     self		:						Union[str, Any]    ,			__UpperCamelCase		:						Union[str, Any]    ,			__UpperCamelCase		:						Any    ,			__UpperCamelCase		:						List[str]="replace"    ,			__UpperCamelCase		:						Optional[int]="<s>"    ,			__UpperCamelCase		:						Optional[Any]="</s>"    ,			__UpperCamelCase		:						List[Any]="</s>"    ,			__UpperCamelCase		:						str="<s>"    ,			__UpperCamelCase		:						Optional[int]="<unk>"    ,			__UpperCamelCase		:						Dict="<pad>"    ,			__UpperCamelCase		:						Union[str, Any]="<mask>"    ,			__UpperCamelCase		:						Any=False    ,			**__UpperCamelCase		:						Optional[Any]    ,			)      ->      Dict:
							"""simple docstring"""





							snake_case__      :   List[str]      =    AddedToken(_UpperCamelCase    ,			lstrip=_UpperCamelCase    ,			rstrip=_UpperCamelCase			) if isinstance(_UpperCamelCase    ,			_UpperCamelCase			) else bos_token
							snake_case__      :   Union[str, Any]      =    AddedToken(_UpperCamelCase    ,			lstrip=_UpperCamelCase    ,			rstrip=_UpperCamelCase			) if isinstance(_UpperCamelCase    ,			_UpperCamelCase			) else eos_token
							snake_case__      :   str      =    AddedToken(_UpperCamelCase    ,			lstrip=_UpperCamelCase    ,			rstrip=_UpperCamelCase			) if isinstance(_UpperCamelCase    ,			_UpperCamelCase			) else sep_token
							snake_case__      :   Optional[int]      =    AddedToken(_UpperCamelCase    ,			lstrip=_UpperCamelCase    ,			rstrip=_UpperCamelCase			) if isinstance(_UpperCamelCase    ,			_UpperCamelCase			) else cls_token
							snake_case__      :   List[Any]      =    AddedToken(_UpperCamelCase    ,			lstrip=_UpperCamelCase    ,			rstrip=_UpperCamelCase			) if isinstance(_UpperCamelCase    ,			_UpperCamelCase			) else unk_token
							snake_case__      :   Union[str, Any]      =    AddedToken(_UpperCamelCase    ,			lstrip=_UpperCamelCase    ,			rstrip=_UpperCamelCase			) if isinstance(_UpperCamelCase    ,			_UpperCamelCase			) else pad_token

							# Mask token behave like a normal word, i.e. include the space before it
							snake_case__      :   Union[str, Any]      =    AddedToken(_UpperCamelCase    ,			lstrip=_UpperCamelCase    ,			rstrip=_UpperCamelCase			) if isinstance(_UpperCamelCase    ,			_UpperCamelCase			) else mask_token

							super().__init__(
							    errors=_UpperCamelCase    ,			bos_token=_UpperCamelCase    ,			eos_token=_UpperCamelCase    ,			unk_token=_UpperCamelCase    ,			sep_token=_UpperCamelCase    ,			cls_token=_UpperCamelCase    ,			pad_token=_UpperCamelCase    ,			mask_token=_UpperCamelCase    ,			add_prefix_space=_UpperCamelCase    ,			**_UpperCamelCase    ,			)
							with open(_UpperCamelCase    ,			encoding='''utf-8'''			) as vocab_handle:
											snake_case__      :   Dict      =    json.load(_UpperCamelCase			)
							snake_case__      :   Optional[int]      =    {v: k for k, v in self.encoder.items()}
							snake_case__      :   Any      =    errors  # how to handle errors in decoding
							snake_case__      :   Tuple      =    bytes_to_unicode()
							snake_case__      :   Optional[Any]      =    {v: k for k, v in self.byte_encoder.items()}
							with open(_UpperCamelCase    ,			encoding='''utf-8'''			) as merges_handle:
											snake_case__      :   List[str]      =    merges_handle.read().split('''\n'''			)[1:-1]
							snake_case__      :   Tuple      =    [tuple(merge.split()			) for merge in bpe_merges]
							snake_case__      :   Optional[Any]      =    dict(zip(_UpperCamelCase    ,			range(len(_UpperCamelCase			)			)			)			)
							snake_case__      :   int      =    {}
							snake_case__      :   Optional[int]      =    add_prefix_space

							# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
							snake_case__      :   Tuple      =    re.compile(R'''\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+'''			)



			@property
			def 				lowerCAmelCase (     self		:						Optional[int]			)      ->      Optional[int]:
							"""simple docstring"""





							return len(self.encoder			)



			def 				lowerCAmelCase (     self		:						Any			)      ->      List[str]:
							"""simple docstring"""





							return dict(self.encoder    ,			**self.added_tokens_encoder			)



			def 				lowerCAmelCase (     self		:						int    ,			__UpperCamelCase		:						Union[str, Any]			)      ->      List[str]:
							"""simple docstring"""





							if token in self.cache:
											return self.cache[token]
							snake_case__      :   Union[str, Any]      =    tuple(_UpperCamelCase			)
							snake_case__      :   List[str]      =    get_pairs(_UpperCamelCase			)

							if not pairs:
											return token

							while True:
											snake_case__      :   Union[str, Any]      =    min(_UpperCamelCase    ,			key=lambda __UpperCamelCase			: self.bpe_ranks.get(_UpperCamelCase    ,			float('''inf'''			)			)			)
											if bigram not in self.bpe_ranks:
															break
											snake_case__  ,      snake_case__      :   Union[str, Any]      =    bigram
											snake_case__      :   Union[str, Any]      =    []
											snake_case__      :   Tuple      =    0
											while i < len(_UpperCamelCase			):
															try:
																			snake_case__      :   Any      =    word.index(_UpperCamelCase    ,			_UpperCamelCase			)
															except ValueError:
																			new_word.extend(word[i:]			)
																			break
															else:
																			new_word.extend(word[i:j]			)
																			snake_case__      :   Dict      =    j

															if word[i] == first and i < len(_UpperCamelCase			) - 1 and word[i + 1] == second:
																			new_word.append(first + second			)
																			i += 2
															else:
																			new_word.append(word[i]			)
																			i += 1
											snake_case__      :   int      =    tuple(_UpperCamelCase			)
											snake_case__      :   Any      =    new_word
											if len(_UpperCamelCase			) == 1:
															break
											else:
															snake_case__      :   Optional[Any]      =    get_pairs(_UpperCamelCase			)
							snake_case__      :   Optional[Any]      =    ''' '''.join(_UpperCamelCase			)
							snake_case__      :   Tuple      =    word
							return word



			def 				lowerCAmelCase (     self		:						Optional[Any]    ,			__UpperCamelCase		:						List[Any]			)      ->      Optional[Any]:
							"""simple docstring"""





							snake_case__      :   Any      =    []
							for token in re.findall(self.pat    ,			_UpperCamelCase			):
											snake_case__      :   str      =    ''''''.join(
											    self.byte_encoder[b] for b in token.encode('''utf-8'''			)			)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
											bpe_tokens.extend(bpe_token for bpe_token in self.bpe(_UpperCamelCase			).split(''' '''			)			)
							return bpe_tokens



			def 				lowerCAmelCase (     self		:						str    ,			__UpperCamelCase		:						Optional[Any]			)      ->      Dict:
							"""simple docstring"""





							return self.encoder.get(_UpperCamelCase    ,			self.encoder.get(self.unk_token			)			)



			def 				lowerCAmelCase (     self		:						Tuple    ,			__UpperCamelCase		:						List[str]			)      ->      int:
							"""simple docstring"""





							return self.decoder.get(_UpperCamelCase			)



			def 				lowerCAmelCase (     self		:						List[Any]    ,			__UpperCamelCase		:						Optional[Any]			)      ->      Any:
							"""simple docstring"""





							snake_case__      :   Dict      =    ''''''.join(_UpperCamelCase			)
							snake_case__      :   str      =    bytearray([self.byte_decoder[c] for c in text]			).decode('''utf-8'''    ,			errors=self.errors			)
							return text



			def 				lowerCAmelCase (     self		:						Any    ,			__UpperCamelCase		:						Optional[Any]    ,			__UpperCamelCase		:						str = None			)      ->      Any:
							"""simple docstring"""





							if not os.path.isdir(_UpperCamelCase			):
											logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''			)
											return
							snake_case__      :   Union[str, Any]      =    os.path.join(
							    _UpperCamelCase    ,			(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']			)
							snake_case__      :   Union[str, Any]      =    os.path.join(
							    _UpperCamelCase    ,			(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file''']			)

							with open(_UpperCamelCase    ,			'''w'''    ,			encoding='''utf-8'''			) as f:
											f.write(json.dumps(self.encoder    ,			indent=2    ,			sort_keys=_UpperCamelCase    ,			ensure_ascii=_UpperCamelCase			) + '''\n'''			)

							snake_case__      :   Union[str, Any]      =    0
							with open(_UpperCamelCase    ,			'''w'''    ,			encoding='''utf-8'''			) as writer:
											writer.write('''#version: 0.2\n'''			)
											for bpe_tokens, token_index in sorted(self.bpe_ranks.items()    ,			key=lambda __UpperCamelCase			: kv[1]			):
															if index != token_index:
																			logger.warning(
																			    F'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
																			    ''' Please check that the tokenizer is not corrupted!'''			)
																			snake_case__      :   Union[str, Any]      =    token_index
															writer.write(''' '''.join(_UpperCamelCase			) + '''\n'''			)
															index += 1

							return vocab_file, merge_file



			def 				lowerCAmelCase (     self		:						Union[str, Any]    ,			__UpperCamelCase		:						Optional[int]    ,			__UpperCamelCase		:						List[Any] = None			)      ->      Optional[int]:
							"""simple docstring"""





							if token_ids_a is None:
											return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
							snake_case__      :   Optional[int]      =    [self.cls_token_id]
							snake_case__      :   List[str]      =    [self.sep_token_id]
							return cls + token_ids_a + sep + sep + token_ids_a + sep



			def 				lowerCAmelCase (     self		:						Union[str, Any]    ,			__UpperCamelCase		:						int    ,			__UpperCamelCase		:						Optional[Any] = None    ,			__UpperCamelCase		:						Dict = False			)      ->      int:
							"""simple docstring"""





							if already_has_special_tokens:
											return super().get_special_tokens_mask(
											    token_ids_a=_UpperCamelCase    ,			token_ids_a=_UpperCamelCase    ,			already_has_special_tokens=_UpperCamelCase			)

							if token_ids_a is None:
											return [1] + ([0] * len(_UpperCamelCase			)) + [1]
							return [1] + ([0] * len(_UpperCamelCase			)) + [1, 1] + ([0] * len(_UpperCamelCase			)) + [1]



			def 				lowerCAmelCase (     self		:						int    ,			__UpperCamelCase		:						Tuple    ,			__UpperCamelCase		:						int = None			)      ->      Any:
							"""simple docstring"""





							snake_case__      :   Optional[Any]      =    [self.sep_token_id]
							snake_case__      :   str      =    [self.cls_token_id]

							if token_ids_a is None:
											return len(cls + token_ids_a + sep			) * [0]
							return len(cls + token_ids_a + sep + sep + token_ids_a + sep			) * [0]







			def 				lowerCAmelCase (     self		:						Optional[int]    ,			__UpperCamelCase		:						Any    ,			__UpperCamelCase		:						int=False    ,			**__UpperCamelCase		:						Optional[int]			)      ->      Dict:
							"""simple docstring"""





							snake_case__      :   Optional[int]      =    kwargs.pop('''add_prefix_space'''    ,			self.add_prefix_space			)
							if (is_split_into_words or add_prefix_space) and (len(_UpperCamelCase			) > 0 and not text[0].isspace()):
											snake_case__      :   Dict      =    ''' ''' + text
							return (text, kwargs)












import argparse
import os
from dataclasses import dataclass

import torch
import torchaudio
from tqdm import tqdm

from transformers import AutoConfig, AutoModelForCTC, AutoProcessor


class      __SCREAMING_SNAKE_CASE       :






						def __init__(						self  ,    _UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase ):






												"""simple docstring"""
												lowerCAmelCase__         =    cuda
												lowerCAmelCase__         =    AutoConfig.from_pretrained(_UpperCamelCase )
												lowerCAmelCase__         =    AutoModelForCTC.from_pretrained(_UpperCamelCase )
												self.model.eval()
												if self.cuda:
																		self.model.to(device='cuda' )
												lowerCAmelCase__         =    AutoProcessor.from_pretrained(_UpperCamelCase )
												lowerCAmelCase__         =    torchaudio.transforms.Resample(_UpperCamelCase  ,    1_60_00 )
												lowerCAmelCase__         =    0
												lowerCAmelCase__         =    list(self.processor.tokenizer.get_vocab().keys() )
												for i in range(len(_UpperCamelCase ) ):
																		if vocab[i] == "[PAD]" or vocab[i] == "<pad>":
																								lowerCAmelCase__         =    i
												print('Blank Token id [PAD]/<pad>'  ,    _UpperCamelCase )
												lowerCAmelCase__         =    blank_id






						def    UpperCamelCase__   (						self  ,    _UpperCamelCase ):






												"""simple docstring"""
												lowerCAmelCase__    ,							lowerCAmelCase__         =    torchaudio.load(_UpperCamelCase )
												lowerCAmelCase__         =    self.resampler(_UpperCamelCase ).squeeze().numpy()
												return speech






						def    UpperCamelCase__   (						self  ,    _UpperCamelCase ):






												"""simple docstring"""
												lowerCAmelCase__         =    self.blank_id
												lowerCAmelCase__         =    '|'.join(item['sent'].split(' ' ) )
												if not os.path.isfile(item['wav_path'] ):
																		print(item['wav_path']  ,    'not found in wavs directory' )

												lowerCAmelCase__         =    self.speech_file_to_array_fn(item['wav_path'] )
												lowerCAmelCase__         =    self.processor(_UpperCamelCase  ,    sampling_rate=1_60_00  ,    return_tensors='pt'  ,    padding=_UpperCamelCase )
												if self.cuda:
																		lowerCAmelCase__         =    inputs.to(device='cuda' )

												with torch.no_grad():
																		lowerCAmelCase__         =    self.model(inputs.input_values ).logits

												# get the emission probability at frame level
												lowerCAmelCase__         =    torch.log_softmax(_UpperCamelCase  ,    dim=-1 )
												lowerCAmelCase__         =    emissions[0].cpu().detach()

												# get labels from vocab
												lowerCAmelCase__         =    ([''] + list(self.processor.tokenizer.get_vocab().keys() ))[
												    :-1
												]  # logits don't align with the tokenizer's vocab

												lowerCAmelCase__         =    {c: i for i, c in enumerate(_UpperCamelCase )}
												lowerCAmelCase__         =    []
												for c in transcript:
																		if c in dictionary:
																								tokens.append(dictionary[c] )

												def get_trellis(_UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase=0 ):
																		lowerCAmelCase__         =    emission.size(0 )
																		lowerCAmelCase__         =    len(_UpperCamelCase )

																		# Trellis has extra diemsions for both time axis and tokens.
																		# The extra dim for tokens represents <SoS> (start-of-sentence)
																		# The extra dim for time axis is for simplification of the code.
																		lowerCAmelCase__         =    torch.full((num_frames + 1, num_tokens + 1)  ,    -float('inf' ) )
																		lowerCAmelCase__         =    0
																		for t in range(_UpperCamelCase ):
																								lowerCAmelCase__         =    torch.maximum(
																								    # Score for staying at the same token
																								    trellis[t, 1:] + emission[t, blank_id]  ,    trellis[t, :-1] + emission[t, tokens]  ,    )
																		return trellis

												lowerCAmelCase__         =    get_trellis(_UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase )


												@dataclass
												class      __SCREAMING_SNAKE_CASE       :
																		_SCREAMING_SNAKE_CASE						:							int
																		_SCREAMING_SNAKE_CASE						:							int
																		_SCREAMING_SNAKE_CASE						:							float

												def backtrack(_UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase=0 ):
																		lowerCAmelCase__         =    trellis.size(1 ) - 1
																		lowerCAmelCase__         =    torch.argmax(trellis[:, j] ).item()

																		lowerCAmelCase__         =    []
																		for t in range(_UpperCamelCase  ,    0  ,    -1 ):
																								# 1. Figure out if the current position was stay or change
																								# Note (again):
																								# `emission[J-1]` is the emission at time frame `J` of trellis dimension.
																								# Score for token staying the same from time frame J-1 to T.
																								lowerCAmelCase__         =    trellis[t - 1, j] + emission[t - 1, blank_id]
																								# Score for token changing from C-1 at T-1 to J at T.
																								lowerCAmelCase__         =    trellis[t - 1, j - 1] + emission[t - 1, tokens[j - 1]]

																								# 2. Store the path with frame-wise probability.
																								lowerCAmelCase__         =    emission[t - 1, tokens[j - 1] if changed > stayed else 0].exp().item()
																								# Return token index and time index in non-trellis coordinate.
																								path.append(Point(j - 1  ,    t - 1  ,    _UpperCamelCase ) )

																								# 3. Update the token
																								if changed > stayed:
																														j -= 1
																														if j == 0:
																																				break
																		else:
																								raise ValueError('Failed to align' )
																		return path[::-1]

												lowerCAmelCase__         =    backtrack(_UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase )


												@dataclass
												class      __SCREAMING_SNAKE_CASE       :
																		_SCREAMING_SNAKE_CASE						:							str
																		_SCREAMING_SNAKE_CASE						:							int
																		_SCREAMING_SNAKE_CASE						:							int
																		_SCREAMING_SNAKE_CASE						:							float






																		def __repr__(						self ):






																								"""simple docstring"""
																								return F"{self.label}\t{self.score:4.2f}\t{self.start*20:5d}\t{self.end*20:5d}"







																		@property
																		def    UpperCamelCase__   (						self ):






																								"""simple docstring"""
																								return self.end - self.start

												def merge_repeats(_UpperCamelCase ):
																		lowerCAmelCase__    ,							lowerCAmelCase__         =    0, 0
																		lowerCAmelCase__         =    []
																		while ia < len(_UpperCamelCase ):
																								while ia < len(_UpperCamelCase ) and path[ia].token_index == path[ia].token_index:
																														ia += 1
																								lowerCAmelCase__         =    sum(path[k].score for k in range(_UpperCamelCase  ,    _UpperCamelCase ) ) / (ia - ia)
																								segments.append(
																								    Segment(
																								        transcript[path[ia].token_index]  ,    path[ia].time_index  ,    path[ia - 1].time_index + 1  ,    _UpperCamelCase  ,    ) )
																								lowerCAmelCase__         =    ia
																		return segments

												lowerCAmelCase__         =    merge_repeats(_UpperCamelCase )
												with open(item['out_path']  ,    'w' ) as out_align:
																		for seg in segments:
																								out_align.write(str(_UpperCamelCase ) + '\n' )







						def    UpperCamelCase__   (						self  ,    _UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase ):






												"""simple docstring"""
												if not os.path.exists(_UpperCamelCase ):
																		os.makedirs(_UpperCamelCase )

												# load text file
												lowerCAmelCase__         =    open(_UpperCamelCase  ,    encoding='utf8' ).readlines()

												lowerCAmelCase__         =    []
												for line in lines:
																		if len(line.strip().split('\t' ) ) != 2:
																								print('Script must be in format: 00001  this is my sentence' )
																								exit()

																		lowerCAmelCase__    ,							lowerCAmelCase__         =    line.strip().split('\t' )
																		lowerCAmelCase__         =    os.path.join(_UpperCamelCase  ,    wav_name + '.wav' )
																		lowerCAmelCase__         =    os.path.join(_UpperCamelCase  ,    wav_name + '.txt' )

																		items.append({'sent': sentence, 'wav_path': wav_path, 'out_path': out_path} )
												print('Number of samples found in script file'  ,    len(_UpperCamelCase ) )

												for item in tqdm(_UpperCamelCase ):
																		self.align_single_sample(_UpperCamelCase )







def 						_UpperCamelCase (     )	-> Tuple:

						"""simple docstring"""



						lowerCAmelCase__         =    argparse.ArgumentParser()

						parser.add_argument(
						    '--model_name'     ,							type=UpperCamelCase_     ,							default='arijitx/wav2vec2-xls-r-300m-bengali'     ,							help='wav2vec model name'		)
						parser.add_argument('--wav_dir'     ,							type=UpperCamelCase_     ,							default='./wavs'     ,							help='directory containing wavs'		)
						parser.add_argument('--text_file'     ,							type=UpperCamelCase_     ,							default='script.txt'     ,							help='file containing text'		)
						parser.add_argument('--input_wavs_sr'     ,							type=UpperCamelCase_     ,							default=1_6000     ,							help='sampling rate of input audios'		)
						parser.add_argument(
						    '--output_dir'     ,							type=UpperCamelCase_     ,							default='./out_alignment'     ,							help='output directory containing the alignment files'		)
						parser.add_argument('--cuda'     ,							action='store_true'		)

						lowerCAmelCase__         =    parser.parse_args()

						lowerCAmelCase__         =    WavaVecaAligner(args.model_name     ,							args.input_wavs_sr     ,							args.cuda		)
						aligner.align_data(args.wav_dir     ,							args.text_file     ,							args.output_dir		)


if __name__ == "__main__":
					main()





