






"""simple docstring"""





import functools
from typing import Any







def 	lowerCamelCase__			(				_lowerCamelCase			:						str						,							_lowerCamelCase			:						list[str]					) ->							bool:

  # Validation
  if not isinstance(_lowerCamelCase						,							_lowerCamelCase					) or len(_lowerCamelCase					) == 0:
    raise ValueError('the string should be not empty string'					)

  if not isinstance(_lowerCamelCase						,							_lowerCamelCase					) or not all(
      isinstance(_lowerCamelCase						,							_lowerCamelCase					) and len(_lowerCamelCase					) > 0 for item in words					):
    raise ValueError('the words should be a list of non-empty strings'					)

  # Build trie
  lowerCamelCase_       	=		{}
  lowerCamelCase_       	=		'WORD_KEEPER'

  for word in words:
    lowerCamelCase_       	=		trie
    for c in word:
      if c not in trie_node:
        lowerCamelCase_       	=		{}

      lowerCamelCase_       	=		trie_node[c]

    lowerCamelCase_       	=		True

  lowerCamelCase_       	=		len(_lowerCamelCase					)

  # Dynamic programming method
  @functools.cache
  def is_breakable(_lowerCamelCase			:						int					) -> bool:
    if index == len_string:
      return True

    lowerCamelCase_       	=		trie
    for i in range(_lowerCamelCase						,							_lowerCamelCase					):
      lowerCamelCase_       	=		trie_node.get(string[i]						,							_lowerCamelCase					)

      if trie_node is None:
        return False

      if trie_node.get(_lowerCamelCase						,							_lowerCamelCase					) and is_breakable(i + 1					):
        return True

    return False

  return is_breakable(0					)


if __name__ == "__main__":
  import doctest

  doctest.testmod()












"""simple docstring"""





import unittest

from datasets import load_dataset

from transformers.pipelines import pipeline
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_torch, slow






@is_pipeline_test
@require_torch
class 	a		(   unittest.TestCase						):






    @require_torch
    def   UpperCamelCase			(			self	:				str   )	->						str:
      lowerCamelCase_       	=		pipeline(
          task='zero-shot-audio-classification'			,		model='hf-internal-testing/tiny-clap-htsat-unfused'   )
      lowerCamelCase_       	=		load_dataset('ashraq/esc50'   )
      lowerCamelCase_       	=		dataset['train']['audio'][-1]['array']
      lowerCamelCase_       	=		audio_classifier(__SCREAMING_SNAKE_CASE			,		candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']   )
      self.assertEqual(
          nested_simplify(__SCREAMING_SNAKE_CASE   )			,		[{'score': 0.501, 'label': 'Sound of a dog'}, {'score': 0.499, 'label': 'Sound of vaccum cleaner'}]			,		)






    @unittest.skip('No models are available in TF'   )
    def   UpperCamelCase			(			self	:				Tuple   )	->						Optional[Any]:
      pass






    @slow
    @require_torch
    def   UpperCamelCase			(			self	:				Optional[Any]   )	->						Optional[Any]:
      lowerCamelCase_       	=		pipeline(
          task='zero-shot-audio-classification'			,		model='laion/clap-htsat-unfused'			,		)
      # This is an audio of a dog
      lowerCamelCase_       	=		load_dataset('ashraq/esc50'   )
      lowerCamelCase_       	=		dataset['train']['audio'][-1]['array']
      lowerCamelCase_       	=		audio_classifier(__SCREAMING_SNAKE_CASE			,		candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']   )

      self.assertEqual(
          nested_simplify(__SCREAMING_SNAKE_CASE   )			,		[
              {'score': 0.999, 'label': 'Sound of a dog'},
              {'score': 0.001, 'label': 'Sound of vaccum cleaner'},
          ]			,		)

      lowerCamelCase_       	=		audio_classifier([audio] * 5			,		candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']   )
      self.assertEqual(
          nested_simplify(__SCREAMING_SNAKE_CASE   )			,		[
              [
                  {'score': 0.999, 'label': 'Sound of a dog'},
                  {'score': 0.001, 'label': 'Sound of vaccum cleaner'},
              ],
          ]
          * 5			,		)
      lowerCamelCase_       	=		audio_classifier(
          [audio] * 5			,		candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']			,		batch_size=5   )
      self.assertEqual(
          nested_simplify(__SCREAMING_SNAKE_CASE   )			,		[
              [
                  {'score': 0.999, 'label': 'Sound of a dog'},
                  {'score': 0.001, 'label': 'Sound of vaccum cleaner'},
              ],
          ]
          * 5			,		)






    @unittest.skip('No models are available in TF'   )
    def   UpperCamelCase			(			self	:				Optional[int]   )	->						int:
      pass




