


'''simple docstring'''







import inspect

import jax
import jax.lax as lax
import jax.numpy as jnp

from ..utils import add_start_docstrings
from ..utils.logging import get_logger


A				:					int    						=			get_logger(__name__)


A				:					int    						=			R'''
    Args:
        input_ids (`jnp.ndarray` of shape `(batch_size, sequence_length)`):
            Indices of input sequence tokens in the vocabulary.

            Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and
            [`PreTrainedTokenizer.__call__`] for details.

            [What are input IDs?](../glossary#input-ids)
        scores (`jnp.ndarray` of shape `(batch_size, config.vocab_size)`):
            Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam
            search or log softmax for each vocabulary token when using beam search
        kwargs (`Dict[str, Any]`, *optional*):
            Additional logits processor specific kwargs.

    Return:
        `jnp.ndarray` of shape `(batch_size, config.vocab_size)`: The processed prediction scores.

'''


class 			__lowerCamelCase			:
    """simple docstring"""


    @add_start_docstrings(SCREAMING_SNAKE_CASE)
    def __call__(  self      :							int				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray):
           raise NotImplementedError(
               F'{self.__class__} is an abstract class. Only classes inheriting this class can be called.')




class 			__lowerCamelCase			:
    """simple docstring"""


    @add_start_docstrings(SCREAMING_SNAKE_CASE)
    def __call__(  self      :							List[str]				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray):
           raise NotImplementedError(
               F'{self.__class__} is an abstract class. Only classes inheriting this class can be called.')




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    @add_start_docstrings(SCREAMING_SNAKE_CASE)
    def __call__(  self      :							str				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							int				,							**SCREAMING_SNAKE_CASE      :							Optional[int]):
           for processor in self:
                  _A					:     Tuple     = inspect.signature(processor.__call__).parameters
                  if len(SCREAMING_SNAKE_CASE) > 3:
                         if not all(arg in kwargs for arg in list(function_args.keys())[2:]):
                                raise ValueError(
                                    F'Make sure that all the required parameters: {list(function_args.keys())} for '
                                    F'{processor.__class__} are passed to the logits processor.')
                         _A					:     Optional[Any]     = processor(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE				,							**SCREAMING_SNAKE_CASE)
                  else:
                         _A					:     Any     = processor(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)
           return scores




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    def __init__(  self      :							Any				,							SCREAMING_SNAKE_CASE      :							float):
           if not isinstance(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE) or not (temperature > 0):
                  raise ValueError(F'`temperature` has to be a strictly positive float, but is {temperature}')

           _A					:     Union[str, Any]     = temperature


    def __call__(  self      :							Optional[Any]				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							int):
           _A					:     List[Any]     = scores / self.temperature
           return scores




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    def __init__(  self      :							Optional[int]				,							SCREAMING_SNAKE_CASE      :							float				,							SCREAMING_SNAKE_CASE      :							float = -float('Inf')				,							SCREAMING_SNAKE_CASE      :							int = 1):
           if not isinstance(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE) or (top_p < 0 or top_p > 1.0):
                  raise ValueError(F'`top_p` has to be a float > 0 and < 1, but is {top_p}')
           if not isinstance(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE) or (min_tokens_to_keep < 1):
                  raise ValueError(F'`min_tokens_to_keep` has to be a positive integer, but is {min_tokens_to_keep}')

           _A					:     str     = top_p
           _A					:     List[Any]     = filter_value
           _A					:     int     = min_tokens_to_keep


    def __call__(  self      :							List[Any]				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							int):
           _A  ,			_A					:     List[Any]     = lax.top_k(SCREAMING_SNAKE_CASE				,							scores.shape[-1])

           _A					:     int     = jnp.full_like(SCREAMING_SNAKE_CASE				,							self.filter_value)
           _A					:     Optional[Any]     = jax.nn.softmax(SCREAMING_SNAKE_CASE				,							axis=-1).cumsum(axis=-1)
           _A					:     Union[str, Any]     = cumulative_probs < self.top_p

           # include the token that is higher than top_p as well
           _A					:     Dict     = jnp.roll(SCREAMING_SNAKE_CASE				,							1)
           score_mask |= score_mask.at[:, 0].set(SCREAMING_SNAKE_CASE)

           # min tokens to keep
           _A					:     Optional[int]     = score_mask.at[:, : self.min_tokens_to_keep].set(SCREAMING_SNAKE_CASE)

           _A					:     Optional[int]     = jnp.where(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)
           _A					:     Union[str, Any]     = jax.lax.sort_key_val(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)[-1]

           return next_scores




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    def __init__(  self      :							str				,							SCREAMING_SNAKE_CASE      :							int				,							SCREAMING_SNAKE_CASE      :							float = -float('Inf')				,							SCREAMING_SNAKE_CASE      :							int = 1):
           if not isinstance(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE) or top_k <= 0:
                  raise ValueError(F'`top_k` has to be a strictly positive integer, but is {top_k}')

           _A					:     Dict     = max(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)
           _A					:     str     = filter_value


    def __call__(  self      :							Any				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							int):
           _A  ,			_A					:     Optional[int]     = scores.shape
           _A					:     Any     = jnp.full(batch_size * vocab_size				,							self.filter_value)

           _A					:     str     = min(self.top_k				,							scores.shape[-1])  # Safety check
           _A  ,			_A					:     List[str]     = lax.top_k(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)
           _A					:     List[Any]     = jnp.broadcast_to((jnp.arange(SCREAMING_SNAKE_CASE) * vocab_size)[:, None]				,							(batch_size, topk)).flatten()
           _A					:     List[str]     = topk_scores.flatten()
           _A					:     int     = topk_indices.flatten() + shift

           _A					:     List[Any]     = next_scores_flat.at[topk_indices_flat].set(SCREAMING_SNAKE_CASE)
           _A					:     Tuple     = next_scores_flat.reshape(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)
           return next_scores




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    def __init__(  self      :							int				,							SCREAMING_SNAKE_CASE      :							int):
           _A					:     List[str]     = bos_token_id


    def __call__(  self      :							str				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							int):
           _A					:     Any     = jnp.full(scores.shape				,							-float('inf'))

           _A					:     Tuple     = 1 - jnp.bool_(cur_len - 1)

           _A					:     List[Any]     = jnp.where(SCREAMING_SNAKE_CASE				,							new_scores.at[:, self.bos_token_id].set(0)				,							SCREAMING_SNAKE_CASE)

           return scores




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    def __init__(  self      :							Dict				,							SCREAMING_SNAKE_CASE      :							int				,							SCREAMING_SNAKE_CASE      :							int):
           _A					:     int     = max_length
           _A					:     str     = eos_token_id


    def __call__(  self      :							int				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							int):
           _A					:     Any     = jnp.full(scores.shape				,							-float('inf'))

           _A					:     int     = 1 - jnp.bool_(cur_len - self.max_length + 1)

           _A					:     Dict     = jnp.where(SCREAMING_SNAKE_CASE				,							new_scores.at[:, self.eos_token_id].set(0)				,							SCREAMING_SNAKE_CASE)

           return scores




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    def __init__(  self      :							str				,							SCREAMING_SNAKE_CASE      :							int				,							SCREAMING_SNAKE_CASE      :							int):
           if not isinstance(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE) or min_length < 0:
                  raise ValueError(F'`min_length` has to be a positive integer, but is {min_length}')

           if not isinstance(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE) or eos_token_id < 0:
                  raise ValueError(F'`eos_token_id` has to be a positive integer, but is {eos_token_id}')

           _A					:     Any     = min_length
           _A					:     List[Any]     = eos_token_id


    def __call__(  self      :							Any				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							int):
           # create boolean flag to decide if min length penalty should be applied
           _A					:     List[str]     = 1 - jnp.clip(cur_len - self.min_length				,							0				,							1)

           _A					:     int     = jnp.where(SCREAMING_SNAKE_CASE				,							scores.at[:, self.eos_token_id].set(-float('inf'))				,							SCREAMING_SNAKE_CASE)

           return scores




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    def __init__(  self      :							str				,							SCREAMING_SNAKE_CASE      :							Optional[int]				,							SCREAMING_SNAKE_CASE      :							Optional[Any]):
           _A					:     Optional[int]     = list(SCREAMING_SNAKE_CASE)
           _A					:     List[str]     = begin_index


    def __call__(  self      :							Optional[int]				,							SCREAMING_SNAKE_CASE      :							str				,							SCREAMING_SNAKE_CASE      :							Any				,							SCREAMING_SNAKE_CASE      :							int):
           _A					:     Union[str, Any]     = 1 - jnp.bool_(cur_len - self.begin_index)

           _A					:     Any     = jnp.where(SCREAMING_SNAKE_CASE				,							scores.at[:, self.begin_suppress_tokens].set(-float('inf'))				,							SCREAMING_SNAKE_CASE)

           return scores




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    def __init__(  self      :							Optional[int]				,							SCREAMING_SNAKE_CASE      :							list):
           _A					:     Tuple     = list(SCREAMING_SNAKE_CASE)


    def __call__(  self      :							List[Any]				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							int):
           _A					:     Tuple     = scores.at[..., self.suppress_tokens].set(-float('inf'))

           return scores




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    def __init__(  self      :							Union[str, Any]				,							SCREAMING_SNAKE_CASE      :							Tuple):
           _A					:     List[str]     = dict(SCREAMING_SNAKE_CASE)
           # Converts the dictionary of format {index: token} containing the tokens to be forced to an array, where the
           # index of the array corresponds to the index of the token to be forced, for XLA compatibility.
           # Indexes without forced tokens will have a negative value.
           _A					:     List[str]     = jnp.ones((max(force_token_map.keys()) + 1)				,							dtype=jnp.intaa) * -1
           for index, token in force_token_map.items():
                  if token is not None:
                         _A					:     Any     = force_token_array.at[index].set(SCREAMING_SNAKE_CASE)
           _A					:     List[Any]     = jnp.intaa(SCREAMING_SNAKE_CASE)


    def __call__(  self      :							Optional[int]				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							jnp.ndarray				,							SCREAMING_SNAKE_CASE      :							int):
           def _force_token(SCREAMING_SNAKE_CASE      :							Optional[Any]):
                  _A					:     Union[str, Any]     = scores.shape[0]
                  _A					:     Optional[int]     = self.force_token_array[generation_idx]

                  _A					:     Union[str, Any]     = jnp.ones_like(SCREAMING_SNAKE_CASE				,							dtype=scores.dtype) * -float('inf')
                  _A					:     List[str]     = jnp.zeros((batch_size, 1)				,							dtype=scores.dtype)
                  _A					:     List[str]     = lax.dynamic_update_slice(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE				,							(0, current_token))
                  return new_scores

           _A					:     List[str]     = lax.cond(
               cur_len >= self.force_token_array.shape[0]				,							lambda: scores				,							lambda: lax.cond(
                   self.force_token_array[cur_len] >= 0				,							lambda: _force_token(SCREAMING_SNAKE_CASE)				,							lambda: scores				,							)				,							)
           return scores




class 			__lowerCamelCase			(	a_	):
    """simple docstring"""


    def __init__(  self      :							int				,							SCREAMING_SNAKE_CASE      :							Any				,							SCREAMING_SNAKE_CASE      :							Optional[Any]				,							SCREAMING_SNAKE_CASE      :							Dict):
           _A					:     List[str]     = generate_config.eos_token_id
           _A					:     List[Any]     = generate_config.no_timestamps_token_id
           _A					:     List[str]     = generate_config.no_timestamps_token_id + 1

           _A					:     Union[str, Any]     = decoder_input_length + 1

           if generate_config.is_multilingual:
                  # room for language token and task token
                  self.begin_index += 2
           if hasattr(SCREAMING_SNAKE_CASE				,							'max_initial_timestamp_index'):
                  _A					:     Dict     = generate_config.max_initial_timestamp_index
           else:
                  _A					:     int     = model_config.vocab_size
           if self.max_initial_timestamp_index is None:
                  _A					:     Tuple     = model_config.vocab_size


    def __call__(  self      :							Union[str, Any]				,							SCREAMING_SNAKE_CASE      :							Dict				,							SCREAMING_SNAKE_CASE      :							List[str]				,							SCREAMING_SNAKE_CASE      :							Optional[int]):
           # suppress <|notimestamps|> which is handled by without_timestamps
           _A					:     Any     = scores.at[:, self.no_timestamps_token_id].set(-float('inf'))

           def handle_pairs(SCREAMING_SNAKE_CASE      :							int				,							SCREAMING_SNAKE_CASE      :							Optional[Any]):
                  _A					:     Any     = jnp.where((cur_len - self.begin_index) >= 1				,							SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)
                  _A					:     str     = jnp.where(
                      input_ids_k[cur_len - 1] >= self.timestamp_begin				,							True and last_was_timestamp				,							SCREAMING_SNAKE_CASE				,							)

                  _A					:     Optional[int]     = jnp.where((cur_len - self.begin_index) < 2				,							SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)
                  _A					:     Optional[int]     = jnp.where(
                      input_ids_k[cur_len - 2] >= self.timestamp_begin				,							SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE				,							)

                  return jnp.where(
                      SCREAMING_SNAKE_CASE				,							jnp.where(
                          penultimate_was_timestamp > 0				,							scores_k.at[self.timestamp_begin :].set(-float('inf'))				,							scores_k.at[: self.eos_token_id].set(-float('inf'))				,							)				,							SCREAMING_SNAKE_CASE				,							)

           _A					:     Tuple     = jax.vmap(SCREAMING_SNAKE_CASE)(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)

           _A					:     List[Any]     = jnp.where(cur_len == self.begin_index				,							SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)
           _A					:     List[Any]     = jnp.where(
               self.max_initial_timestamp_index is not None				,							True and apply_max_initial_timestamp				,							SCREAMING_SNAKE_CASE				,							)

           _A					:     List[Any]     = self.timestamp_begin + self.max_initial_timestamp_index

           _A					:     Tuple     = jnp.where(
               SCREAMING_SNAKE_CASE				,							scores.at[:, last_allowed + 1 :].set(-float('inf'))				,							SCREAMING_SNAKE_CASE				,							)

           # if sum of probability over timestamps is above any other token, sample timestamp
           _A					:     str     = jax.nn.log_softmax(SCREAMING_SNAKE_CASE				,							axis=-1)

           def handle_cumulative_probs(SCREAMING_SNAKE_CASE      :							List[Any]				,							SCREAMING_SNAKE_CASE      :							Optional[Any]):
                  _A					:     List[Any]     = jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]				,							axis=-1)
                  _A					:     Union[str, Any]     = jnp.max(logprobs_k[: self.timestamp_begin])
                  return jnp.where(
                      timestamp_logprob > max_text_token_logprob				,							scores_k.at[: self.timestamp_begin].set(-float('inf'))				,							SCREAMING_SNAKE_CASE				,							)

           _A					:     List[str]     = jax.vmap(SCREAMING_SNAKE_CASE)(SCREAMING_SNAKE_CASE				,							SCREAMING_SNAKE_CASE)

           return scores










'''simple docstring'''







# This code is adapted from OpenAI's release
# https://github.com/openai/human-eval/blob/master/human_eval/execution.py

import contextlib
import faulthandler
import io
import multiprocessing
import os
import platform
import signal
import tempfile






def 				lowerCAmelCase__	(    lowerCamelCase					:      Optional[int]  ,lowerCamelCase					:      List[Any]  ,lowerCamelCase					:      Tuple  ,lowerCamelCase					:      List[str]       ):
       _A					:     Dict     = multiprocessing.Manager()
       _A					:     List[Any]     = manager.list()

       _A					:     Dict     = multiprocessing.Process(target=lowerCamelCase  ,args=(check_program, result, timeout)       )
       p.start()
       p.join(timeout=timeout + 1       )
       if p.is_alive():
              p.kill()

       if not result:
              result.append('timed out'       )

       return {
           "task_id": task_id,
           "passed": result[0] == "passed",
           "result": result[0],
           "completion_id": completion_id,
       }






def 				lowerCAmelCase__	(    lowerCamelCase					:      Optional[int]  ,lowerCamelCase					:      Union[str, Any]  ,lowerCamelCase					:      Optional[Any]       ):
       with create_tempdir():
              # These system calls are needed when cleaning up tempdir.
              import os
              import shutil

              _A					:     Any     = shutil.rmtree
              _A					:     Optional[int]     = os.rmdir
              _A					:     str     = os.chdir

              # Disable functionalities that can make destructive changes to the test.
              reliability_guard()

              # Run program.
              try:
                     _A					:     str     = {}
                     with swallow_io():
                            with time_limit(lowerCamelCase       ):
                                   exec(lowerCamelCase  ,lowerCamelCase       )
                     result.append('passed'       )
              except TimeoutException:
                     result.append('timed out'       )
              except BaseException as e:
                     result.append(F'failed: {e}'       )

              # Needed for cleaning up.
              _A					:     Optional[int]     = rmtree
              _A					:     Optional[Any]     = rmdir
              _A					:     Dict     = chdir






@contextlib.contextmanager
def 				lowerCAmelCase__	(    lowerCamelCase					:      int       ):
       def signal_handler(lowerCamelCase					:      str  ,lowerCamelCase					:      Any       ):
              raise TimeoutException('Timed out!'       )

       signal.setitimer(signal.ITIMER_REAL  ,lowerCamelCase       )
       signal.signal(signal.SIGALRM  ,lowerCamelCase       )
       try:
              yield
       finally:
              signal.setitimer(signal.ITIMER_REAL  ,0       )






@contextlib.contextmanager
def 				lowerCAmelCase__	(    ):
       _A					:     Any     = WriteOnlyStringIO()
       with contextlib.redirect_stdout(lowerCamelCase       ):
              with contextlib.redirect_stderr(lowerCamelCase       ):
                     with redirect_stdin(lowerCamelCase       ):
                            yield






@contextlib.contextmanager
def 				lowerCAmelCase__	(    ):
       with tempfile.TemporaryDirectory() as dirname:
              with chdir(lowerCamelCase       ):
                     yield dirname


class 			__lowerCamelCase			(	a_	):
    """simple docstring"""
    pass




class 			__lowerCamelCase			(	io.StringIO	):
    """simple docstring"""


    def        A   (  self      :							Tuple				,							*SCREAMING_SNAKE_CASE      :							Any				,							**SCREAMING_SNAKE_CASE      :							Dict):
           raise OSError


    def        A   (  self      :							Optional[int]				,							*SCREAMING_SNAKE_CASE      :							List[str]				,							**SCREAMING_SNAKE_CASE      :							Optional[Any]):
           raise OSError


    def        A   (  self      :							Optional[int]				,							*SCREAMING_SNAKE_CASE      :							str				,							**SCREAMING_SNAKE_CASE      :							Optional[int]):
           raise OSError


    def        A   (  self      :							Union[str, Any]				,							*SCREAMING_SNAKE_CASE      :							Optional[int]				,							**SCREAMING_SNAKE_CASE      :							Tuple):
           return False




class 			__lowerCamelCase			(	contextlib._RedirectStream	):  # type: ignore
    """simple docstring"""
    a													=   "stdin"






@contextlib.contextmanager
def 				lowerCAmelCase__	(    lowerCamelCase					:      Tuple       ):
       if root == ".":
              yield
              return
       _A					:     Any     = os.getcwd()
       os.chdir(lowerCamelCase       )
       try:
              yield
       except BaseException as exc:
              raise exc
       finally:
              os.chdir(lowerCamelCase       )






def 				lowerCAmelCase__	(    lowerCamelCase					:      List[Any]=None       ):

       if maximum_memory_bytes is not None:
              import resource

              resource.setrlimit(resource.RLIMIT_AS  ,(maximum_memory_bytes, maximum_memory_bytes)       )
              resource.setrlimit(resource.RLIMIT_DATA  ,(maximum_memory_bytes, maximum_memory_bytes)       )
              if not platform.uname().system == "Darwin":
                     resource.setrlimit(resource.RLIMIT_STACK  ,(maximum_memory_bytes, maximum_memory_bytes)       )

       faulthandler.disable()

       import builtins

       _A					:     List[Any]     = None
       _A					:     Dict     = None

       import os

       _A					:     Union[str, Any]     = '1'

       _A					:     int     = None
       _A					:     Optional[int]     = None
       _A					:     int     = None
       _A					:     Any     = None
       _A					:     Optional[int]     = None
       _A					:     Union[str, Any]     = None
       _A					:     List[Any]     = None
       _A					:     int     = None
       _A					:     List[Any]     = None
       _A					:     Tuple     = None
       _A					:     Any     = None
       _A					:     Tuple     = None
       _A					:     Optional[int]     = None
       _A					:     Optional[Any]     = None
       _A					:     str     = None
       _A					:     Dict     = None
       _A					:     List[str]     = None
       _A					:     Union[str, Any]     = None
       _A					:     Union[str, Any]     = None
       _A					:     str     = None
       _A					:     str     = None
       _A					:     str     = None
       _A					:     Any     = None
       _A					:     Union[str, Any]     = None
       _A					:     str     = None
       _A					:     List[str]     = None
       _A					:     Union[str, Any]     = None

       import shutil

       _A					:     int     = None
       _A					:     Any     = None
       _A					:     List[Any]     = None

       import subprocess

       _A					:     Optional[Any]     = None  # type: ignore

       _A					:     List[Any]     = None

       import sys

       _A					:     Any     = None
       _A					:     Tuple     = None
       _A					:     str     = None
       _A					:     Tuple     = None
       _A					:     List[str]     = None






