


"""simple docstring"""



from __future__ import annotations

__snake_case       =       list[list[int]]

# assigning initial values to the grid
__snake_case       =       [
    [3, 0, 6, 5, 0, 8, 4, 0, 0],
    [5, 2, 0, 0, 0, 0, 0, 0, 0],
    [0, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]

# a grid with no solution
__snake_case       =       [
    [5, 0, 6, 5, 0, 8, 4, 0, 3],
    [5, 2, 0, 0, 0, 0, 0, 0, 2],
    [1, 8, 7, 0, 0, 0, 0, 3, 1],
    [0, 0, 3, 0, 1, 0, 0, 8, 0],
    [9, 0, 0, 8, 6, 3, 0, 0, 5],
    [0, 5, 0, 0, 9, 0, 6, 0, 0],
    [1, 3, 0, 0, 0, 0, 2, 5, 0],
    [0, 0, 0, 0, 0, 0, 0, 7, 4],
    [0, 0, 5, 2, 0, 6, 3, 0, 0],
]







def     __lowerCAmelCase		(		lowercase    :    Matrix		,				lowercase    :    int		,				lowercase    :    int		,				lowercase    :    int					)      ->		bool:


    """simple docstring"""





    for i in range(9					):
        if grid[row][i] == n or grid[i][column] == n:
            return False

    for i in range(3					):
        for j in range(3					):
            if grid[(row - row % 3) + i][(column - column % 3) + j] == n:
                return False

    return True







def     __lowerCAmelCase		(		lowercase    :    Matrix					)      ->		tuple[int, int] | None:


    """simple docstring"""





    for i in range(9					):
        for j in range(9					):
            if grid[i][j] == 0:
                return i, j
    return None







def     __lowerCAmelCase		(		lowercase    :    Matrix					)      ->		Matrix | None:


    """simple docstring"""





    if location := find_empty_location(lowercase					):
        snake_case   ,snake_case       : int    =       location
    else:
        # If the location is ``None``, then the grid is solved.
        return grid

    for digit in range(1		,				10					):
        if is_safe(lowercase		,				lowercase		,				lowercase		,				lowercase					):
            snake_case       : str    =       digit

            if sudoku(lowercase					) is not None:
                return grid

            snake_case       : List[Any]    =       0

    return None







def     __lowerCAmelCase		(		lowercase    :    Matrix					)      ->		None:


    """simple docstring"""





    for row in grid:
        for cell in row:
            print(lowercase		,				end=" "					)
        print()


if __name__ == "__main__":
  # make a copy of grid so that you can compare with the unmodified grid
  for example_grid in (initial_grid, no_solution):
    print("""\nExample grid:\n""" + """=""" * 20)
    print_solution(example_grid)
    print("""\nExample grid solution:""")
    __snake_case       =       sudoku(example_grid)
    if solution is not None:
      print_solution(solution)
    else:
      print("""Cannot find a solution.""")









"""simple docstring"""



# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool







class _lowerCAmelCase							( snake_case_      ):
   __UpperCAmelCase					:			List[str]				    =    '''openai/whisper-base'''
   __UpperCAmelCase					:			Any				    =    (
       '''This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the '''
       '''transcribed text.'''
   )
   __UpperCAmelCase					:			Tuple				    =    '''transcriber'''
   __UpperCAmelCase					:			Union[str, Any]				    =    WhisperProcessor
   __UpperCAmelCase					:			str				    =    WhisperForConditionalGeneration

   __UpperCAmelCase					:			int				    =    ['''audio''']
   __UpperCAmelCase					:			Optional[int]				    =    ['''text''']







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		)      ->						Tuple:

       '''simple docstring'''




       return self.pre_processor(UpperCamelCase__		,      return_tensors="pt"		).input_features







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		)      ->						int:

       '''simple docstring'''




       return self.model.generate(inputs=UpperCamelCase__		)







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		)      ->						Optional[Any]:

       '''simple docstring'''




       return self.pre_processor.batch_decode(UpperCamelCase__		,      skip_special_tokens=UpperCamelCase__		)[0]





