






'''simple docstring'''







import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin




class   __SCREAMING_SNAKE_CASE       (__A       ):


  """simple docstring"""


  _a  : List[Any]      			=     '''MCTCTFeatureExtractor'''
  _a  : List[Any]      			=     '''AutoTokenizer'''







  def __init__(			self   ,	UpperCamelCase__   ,	UpperCamelCase__	):






         """simple docstring"""


         super().__init__(UpperCamelCase__   ,	UpperCamelCase__	)
         a_						     =			self.feature_extractor
         a_						     =			False







  def __call__(			self   ,	*UpperCamelCase__   ,	**UpperCamelCase__	):






         """simple docstring"""


         if self._in_target_context_manager:
                return self.current_processor(*UpperCamelCase__   ,	**UpperCamelCase__	)

         if "raw_speech" in kwargs:
                warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'	)
                a_						     =			kwargs.pop('raw_speech'	)
         else:
                a_						     =			kwargs.pop('audio'   ,	UpperCamelCase__	)
         a_						     =			kwargs.pop('sampling_rate'   ,	UpperCamelCase__	)
         a_						     =			kwargs.pop('text'   ,	UpperCamelCase__	)
         if len(UpperCamelCase__	) > 0:
                a_						     =			args[0]
                a_						     =			args[1:]

         if audio is None and text is None:
                raise ValueError('You need to specify either an `audio` or `text` input to process.'	)

         if audio is not None:
                a_						     =			self.feature_extractor(UpperCamelCase__   ,	*UpperCamelCase__   ,	sampling_rate=UpperCamelCase__   ,	**UpperCamelCase__	)
         if text is not None:
                a_						     =			self.tokenizer(UpperCamelCase__   ,	**UpperCamelCase__	)

         if text is None:
                return inputs
         elif audio is None:
                return encodings
         else:
                a_						     =			encodings['input_ids']
                return inputs







  def    _a       (			self   ,	*UpperCamelCase__   ,	**UpperCamelCase__	):






         """simple docstring"""


         return self.tokenizer.batch_decode(*UpperCamelCase__   ,	**UpperCamelCase__	)







  def    _a       (			self   ,	*UpperCamelCase__   ,	**UpperCamelCase__	):






         """simple docstring"""


         if self._in_target_context_manager:
                return self.current_processor.pad(*UpperCamelCase__   ,	**UpperCamelCase__	)

         a_						     =			kwargs.pop('input_features'   ,	UpperCamelCase__	)
         a_						     =			kwargs.pop('labels'   ,	UpperCamelCase__	)
         if len(UpperCamelCase__	) > 0:
                a_						     =			args[0]
                a_						     =			args[1:]

         if input_features is not None:
                a_						     =			self.feature_extractor.pad(UpperCamelCase__   ,	*UpperCamelCase__   ,	**UpperCamelCase__	)
         if labels is not None:
                a_						     =			self.tokenizer.pad(UpperCamelCase__   ,	**UpperCamelCase__	)

         if labels is None:
                return input_features
         elif input_features is None:
                return labels
         else:
                a_						     =			labels['input_ids']
                return input_features







  def    _a       (			self   ,	*UpperCamelCase__   ,	**UpperCamelCase__	):






         """simple docstring"""


         return self.tokenizer.decode(*UpperCamelCase__   ,	**UpperCamelCase__	)







  @contextmanager
  def    _a       (			self	):






         """simple docstring"""


         warnings.warn(
             '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
             'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
             'your audio inputs, or in a separate call.'	)
         a_						     =			True
         a_						     =			self.tokenizer
         yield
         a_						     =			self.feature_extractor
         a_						     =			False












'''simple docstring'''







import json
import logging
import os
import socket

import git
import numpy as np
import torch


logging.basicConfig(
    format="%(asctime)s - %(levelname)s - %(name)s - PID: %(process)d -  %(message)s",
    datefmt="%m/%d/%Y %H:%M:%S",
    level=logging.INFO,
)
__lowerCAmelCase        =							logging.getLogger(__name__)


def       __UpperCamelCase					(      lowercase_       :  str   ):
       """simple docstring"""




       a_						     =			git.Repo(search_parent_directories=lowercase_   )
       a_						     =			{
           'repo_id': str(lowercase_   ),
           'repo_sha': str(repo.head.object.hexsha   ),
           'repo_branch': str(repo.active_branch   ),
       }

       with open(os.path.join(lowercase_   ,       'git_log.json'   )   ,       'w'   ) as f:
              json.dump(lowercase_   ,       lowercase_   ,       indent=4   )


def       __UpperCamelCase					(      lowercase_       :  List[Any]   ):
       """simple docstring"""




       if params.n_gpu <= 0:
              a_						     =			0
              a_						     =			-1
              a_						     =			True
              a_						     =			False
              return

       assert torch.cuda.is_available()

       logger.info('Initializing GPUs'   )
       if params.n_gpu > 1:
              assert params.local_rank != -1

              a_						     =			int(os.environ['WORLD_SIZE']   )
              a_						     =			int(os.environ['N_GPU_NODE']   )
              a_						     =			int(os.environ['RANK']   )

              # number of nodes / node ID
              a_						     =			params.world_size // params.n_gpu_per_node
              a_						     =			params.global_rank // params.n_gpu_per_node
              a_						     =			True

              assert params.n_nodes == int(os.environ['N_NODES']   )
              assert params.node_id == int(os.environ['NODE_RANK']   )

       # local job (single GPU)
       else:
              assert params.local_rank == -1

              a_						     =			1
              a_						     =			0
              a_						     =			0
              a_						     =			0
              a_						     =			1
              a_						     =			1
              a_						     =			False

       # sanity checks
       assert params.n_nodes >= 1
       assert 0 <= params.node_id < params.n_nodes
       assert 0 <= params.local_rank <= params.global_rank < params.world_size
       assert params.world_size == params.n_nodes * params.n_gpu_per_node

       # define whether this is the master process / if we are in multi-node distributed mode
       a_						     =			params.node_id == 0 and params.local_rank == 0
       a_						     =			params.n_nodes > 1

       # summary
       a_						     =			F'--- Global rank: {params.global_rank} - '
       logger.info(PREFIX + 'Number of nodes: %i' % params.n_nodes   )
       logger.info(PREFIX + 'Node ID        : %i' % params.node_id   )
       logger.info(PREFIX + 'Local rank     : %i' % params.local_rank   )
       logger.info(PREFIX + 'World size     : %i' % params.world_size   )
       logger.info(PREFIX + 'GPUs per node  : %i' % params.n_gpu_per_node   )
       logger.info(PREFIX + 'Master         : %s' % str(params.is_master   )   )
       logger.info(PREFIX + 'Multi-node     : %s' % str(params.multi_node   )   )
       logger.info(PREFIX + 'Multi-GPU      : %s' % str(params.multi_gpu   )   )
       logger.info(PREFIX + 'Hostname       : %s' % socket.gethostname()   )

       # set GPU device
       torch.cuda.set_device(params.local_rank   )

       # initialize multi-GPU
       if params.multi_gpu:
              logger.info('Initializing PyTorch distributed'   )
              torch.distributed.init_process_group(
                  init_method='env://'   ,       backend='nccl'   ,       )


def       __UpperCamelCase					(      lowercase_       :  Union[str, Any]   ):
       """simple docstring"""




       np.random.seed(args.seed   )
       torch.manual_seed(args.seed   )
       if args.n_gpu > 0:
              torch.cuda.manual_seed_all(args.seed   )




