






'''simple docstring'''





import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding







class 	_UpperCAmelCase  (  _A		):




      """simple docstring"""



      A          =    ['''image_processor''', '''tokenizer''']
      A          =    '''CLIPImageProcessor'''
      A          =    ('''CLIPTokenizer''', '''CLIPTokenizerFast''')
      def __init__(   self    ,	_lowerCAmelCase=None    ,	_lowerCAmelCase=None    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          lowerCAmelCase__   :Any      							=				None
          if "feature_extractor" in kwargs:
              warnings.warn(
                  "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
                  " instead."    ,	_lowerCAmelCase    ,	)
              lowerCAmelCase__   :int      							=				kwargs.pop("feature_extractor"		)

          lowerCAmelCase__   :Any      							=				image_processor if image_processor is not None else feature_extractor
          if image_processor is None:
              raise ValueError("You need to specify an `image_processor`."		)
          if tokenizer is None:
              raise ValueError("You need to specify a `tokenizer`."		)

          super().__init__(_lowerCAmelCase    ,	_lowerCAmelCase		)
      def __call__(   self    ,	_lowerCAmelCase=None    ,	_lowerCAmelCase=None    ,	_lowerCAmelCase=None    ,	**_lowerCAmelCase		):



          '''simple docstring'''

          if text is None and images is None:
              raise ValueError("You have to specify either text or images. Both cannot be none."		)

          if text is not None:
              lowerCAmelCase__   :Optional[Any]      							=				self.tokenizer(_lowerCAmelCase    ,	return_tensors=_lowerCAmelCase    ,	**_lowerCAmelCase		)

          if images is not None:
              lowerCAmelCase__   :str      							=				self.image_processor(_lowerCAmelCase    ,	return_tensors=_lowerCAmelCase    ,	**_lowerCAmelCase		)

          if text is not None and images is not None:
              lowerCAmelCase__   :int      							=				image_features.pixel_values
              return encoding
          elif text is not None:
              return encoding
          else:
              return BatchEncoding(data=dict(**_lowerCAmelCase		)    ,	tensor_type=_lowerCAmelCase		)
      def 			snake_case_      (   self    ,	*_lowerCAmelCase    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          return self.tokenizer.batch_decode(*_lowerCAmelCase    ,	**_lowerCAmelCase		)
      def 			snake_case_      (   self    ,	*_lowerCAmelCase    ,	**_lowerCAmelCase		):



          '''simple docstring'''
          return self.tokenizer.decode(*_lowerCAmelCase    ,	**_lowerCAmelCase		)
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          lowerCAmelCase__   :List[Any]      							=				self.tokenizer.model_input_names
          lowerCAmelCase__   :Optional[int]      							=				self.image_processor.model_input_names
          return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names		)		)
      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          warnings.warn(
              "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."    ,	_lowerCAmelCase    ,	)
          return self.image_processor_class



      @property
      def 			snake_case_      (   self		):



          '''simple docstring'''
          warnings.warn(
              "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."    ,	_lowerCAmelCase    ,	)
          return self.image_processor











def 				snake_case__							(							UpperCAmelCase							:  float    ,			UpperCAmelCase							:  list[float]       ):
    if discount_rate < 0:
        raise ValueError("Discount rate cannot be negative"       )
    if not cash_flows:
        raise ValueError("Cash flows list cannot be empty"       )
    lowerCAmelCase__   :List[Any]      							=				sum(
        cash_flow / ((1 + discount_rate) ** i) for i, cash_flow in enumerate(UpperCAmelCase       )       )
    return round(UpperCAmelCase    ,			ndigits=2       )


if __name__ == "__main__":
 import doctest

 doctest.testmod()



