

import torch
import torch.nn.functional as F

from diffusers import VQDiffusionScheduler

from .test_schedulers import SchedulerCommonTest






class 							A_				(	snake_case__      ):
     _lowercase    :  Optional[int]          =			(VQDiffusionScheduler,)


     def 						UpperCAmelCase						(							self    :	Tuple    ,						**UpperCAmelCase    :	List[str]      )							->			str:
      __lowerCAmelCase:     List[str]     			=   {
          'num_vec_classes': 4_0_9_7,
          'num_train_timesteps': 1_0_0,
      }

      config.update(**UpperCAmelCase      )
      return config


     def 						UpperCAmelCase						(							self    :	Optional[Any]    ,						UpperCAmelCase    :	str      )							->			List[str]:
      __lowerCAmelCase:     List[str]     			=   4
      __lowerCAmelCase:     List[Any]     			=   8
      __lowerCAmelCase:     List[Any]     			=   8

      __lowerCAmelCase:     List[Any]     			=   torch.randint(0    ,						UpperCAmelCase    ,						(batch_size, height * width)      )

      return sample


     @property
     def 						UpperCAmelCase						(							self    :	int      )							->			Optional[int]:
      assert False


     def 						UpperCAmelCase						(							self    :	Any    ,						UpperCAmelCase    :	Union[str, Any]      )							->			Optional[Any]:
      def model(UpperCAmelCase    :	List[Any]    ,						UpperCAmelCase    :	List[str]    ,						*UpperCAmelCase    :	Any      ):
       __lowerCAmelCase			,							__lowerCAmelCase:     Tuple     			=   sample.shape
       __lowerCAmelCase:     Dict     			=   torch.rand((batch_size, num_vec_classes - 1, num_latent_pixels)      )
       __lowerCAmelCase:     Optional[int]     			=   F.log_softmax(logits.double()    ,						dim=1      ).float()
       return return_value

      return model


     def 						UpperCAmelCase						(							self    :	Any      )							->			Union[str, Any]:
      for timesteps in [2, 5, 1_0_0, 1_0_0_0]:
       self.check_over_configs(num_train_timesteps=UpperCAmelCase      )


     def 						UpperCAmelCase						(							self    :	Optional[Any]      )							->			Optional[int]:
      for num_vec_classes in [5, 1_0_0, 1_0_0_0, 4_0_0_0]:
       self.check_over_configs(num_vec_classes=UpperCAmelCase      )


     def 						UpperCAmelCase						(							self    :	Tuple      )							->			Any:
      for t in [0, 5_0, 9_9]:
       self.check_over_forward(time_step=UpperCAmelCase      )


     def 						UpperCAmelCase						(							self    :	List[Any]      )							->			Optional[int]:
      pass








# Copyright 2023 The HuggingFace 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 typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
    is_vision_available,
)


_a	 =     {
    '''configuration_tvlt''': ['''TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TvltConfig'''],
    '''feature_extraction_tvlt''': ['''TvltFeatureExtractor'''],
    '''processing_tvlt''': ['''TvltProcessor'''],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a	 =     [
      '''TVLT_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''TvltModel''',
      '''TvltForPreTraining''',
      '''TvltForAudioVisualClassification''',
      '''TvltPreTrainedModel''',
  ]

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a	 =     ['''TvltImageProcessor''']


if TYPE_CHECKING:
  from .configuration_tvlt import TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP, TvltConfig
  from .processing_tvlt import TvltProcessor
  from .feature_extraction_tvlt import TvltFeatureExtractor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tvlt import (
        TVLT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TvltForAudioVisualClassification,
        TvltForPreTraining,
        TvltModel,
        TvltPreTrainedModel,
    )

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_tvlt import TvltImageProcessor


else:
  import sys

  _a	 =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





