"""simple docstring"""







from typing import Optional, Tuple

import flax.linen as nn
import jax
import jax.numpy as jnp
from configuration_hybrid_clip import HybridCLIPConfig
from flax.core.frozen_dict import FrozenDict

from transformers import FLAX_MODEL_MAPPING, FlaxCLIPVisionModel
from transformers.modeling_flax_utils import FlaxPreTrainedModel
from transformers.models.clip.modeling_flax_clip import FlaxCLIPOutput
from transformers.utils import logging


UpperCamelCase_							:							str				 =		logging.get_logger(__name__)


class       _lowercase		( nn.Module	):
				lowerCamelCase__							=							4_2
				lowerCamelCase__							=							jnp.floataa

				def 							A			(  self							:     int  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.config.text_config
										UpperCAmelCase__       						=		self.config.vision_config

										UpperCAmelCase__       						=		self.config.projection_dim
										UpperCAmelCase__       						=		text_config.hidden_size
										UpperCAmelCase__       						=		vision_config.hidden_size

										UpperCAmelCase__       						=		FLAX_MODEL_MAPPING[self.config.text_config.__class__].module_class
										UpperCAmelCase__       						=		FLAX_MODEL_MAPPING.get(self.config.vision_config.__class__							,     a__  ).module_class

										UpperCAmelCase__       						=		text_module(a__							,     dtype=self.dtype  )
										UpperCAmelCase__       						=		vision_module(a__							,     dtype=self.dtype  )

										UpperCAmelCase__       						=		nn.Dense(
										    self.projection_dim							,     dtype=self.dtype							,     kernel_init=jax.nn.initializers.normal(0.02  )							,     use_bias=a__							,     )
										UpperCAmelCase__       						=		nn.Dense(
										    self.projection_dim							,     dtype=self.dtype							,     kernel_init=jax.nn.initializers.normal(0.02  )							,     use_bias=a__							,     )
										UpperCAmelCase__       						=		self.param("""logit_scale"""							,     jax.nn.initializers.ones							,     []  )

				def __call__(  self							:     Tuple							,     _lowercase							:     Tuple=None							,     _lowercase							:     Any=None							,     _lowercase							:     Union[str, Any]=None							,     _lowercase							:     List[Any]=None							,     _lowercase							:     Dict=None							,     _lowercase							:     Union[str, Any] = True							,     _lowercase							:     List[Any]=None							,     _lowercase							:     Optional[Any]=None							,     _lowercase							:     Dict=None							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		return_dict if return_dict is not None else self.config.return_dict

										UpperCAmelCase__       						=		self.vision_model(
										    pixel_values=a__							,     deterministic=a__							,     output_attentions=a__							,     output_hidden_states=a__							,     return_dict=a__							,     )

										UpperCAmelCase__       						=		self.text_model(
										    input_ids=a__							,     attention_mask=a__							,     token_type_ids=a__							,     position_ids=a__							,     deterministic=a__							,     output_attentions=a__							,     output_hidden_states=a__							,     return_dict=a__							,     )

										UpperCAmelCase__       						=		vision_outputs[1]
										UpperCAmelCase__       						=		self.visual_projection(a__  )

										UpperCAmelCase__       						=		text_outputs[1]
										UpperCAmelCase__       						=		self.text_projection(a__  )

										# normalized features
										UpperCAmelCase__       						=		image_embeds / jnp.linalg.norm(a__							,     axis=-1							,     keepdims=a__  )
										UpperCAmelCase__       						=		text_embeds / jnp.linalg.norm(a__							,     axis=-1							,     keepdims=a__  )

										# cosine similarity as logits
										UpperCAmelCase__       						=		jnp.exp(self.logit_scale  )
										UpperCAmelCase__       						=		jnp.matmul(a__							,     image_embeds.T  ) * logit_scale
										UpperCAmelCase__       						=		logits_per_text.T

										if not return_dict:
																return (logits_per_image, logits_per_text, text_embeds, image_embeds, text_outputs, vision_outputs)

										return FlaxCLIPOutput(
										    logits_per_image=a__							,     logits_per_text=a__							,     text_embeds=a__							,     image_embeds=a__							,     text_model_output=a__							,     vision_model_output=a__							,     )


class       _lowercase		( lowercase_	):
				lowerCamelCase__							=							HybridCLIPConfig
				lowerCamelCase__							=							FlaxHybridCLIPModule

				def __init__(  self							:     Tuple							,     _lowercase							:     List[str]							,     _lowercase							:     Tuple = None							,     _lowercase							:     List[str] = 0							,     _lowercase							:     List[Any] = jnp.floataa							,     **_lowercase							:     Dict							,     ):


										'''simple docstring'''
										if input_shape is None:
																UpperCAmelCase__       						=		((1, 1), (1, config.vision_config.image_size, config.vision_config.image_size, 3))

										UpperCAmelCase__       						=		self.module_class(config=a__							,     dtype=a__							,     **a__  )
										super().__init__(a__							,     a__							,     input_shape=a__							,     seed=a__							,     dtype=a__  )

				def 							A			(  self							:     str							,     _lowercase							:     Any							,     _lowercase							:     int							,     _lowercase							:     Union[str, Any] = None  ):


										'''simple docstring'''
										# init input tensor
										UpperCAmelCase__       						=		jnp.zeros(input_shape[0]							,     dtype="""i4"""  )
										UpperCAmelCase__       						=		jnp.broadcast_to(jnp.arange(jnp.atleast_ad(a__  ).shape[-1]  )							,     input_shape[0]  )
										UpperCAmelCase__       						=		jnp.ones_like(a__  )
										UpperCAmelCase__       						=		jnp.ones_like(a__  )

										UpperCAmelCase__       						=		jax.random.normal(a__							,     input_shape[1]  )

										UpperCAmelCase__						,   UpperCAmelCase__       						=		jax.random.split(a__  )
										UpperCAmelCase__       						=		{"""params""": params_rng, """dropout""": dropout_rng}

										return self.module.init(a__							,     a__							,     a__							,     a__							,     a__							,     a__  )["params"]

				def __call__(  self							:     int							,     _lowercase							:     str							,     _lowercase							:     List[str]							,     _lowercase							:     Dict=None							,     _lowercase							:     Any=None							,     _lowercase							:     Optional[Any]=None							,     _lowercase							:     Any = None							,     _lowercase							:     Any = None							,     _lowercase							:     Union[str, Any] = False							,     _lowercase							:     Union[str, Any] = None							,     _lowercase							:     Union[str, Any] = None							,     _lowercase							:     str = None							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		output_attentions if output_attentions is not None else self.config.output_attentions
										UpperCAmelCase__       						=		(
										    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
										)
										UpperCAmelCase__       						=		return_dict if return_dict is not None else self.config.return_dict

										if position_ids is None:
																UpperCAmelCase__       						=		jnp.broadcast_to(jnp.arange(jnp.atleast_ad(a__  ).shape[-1]  )							,     input_ids.shape  )

										if token_type_ids is None:
																UpperCAmelCase__       						=		jnp.zeros_like(a__  )

										if attention_mask is None:
																UpperCAmelCase__       						=		jnp.ones_like(a__  )

										# Handle any PRNG if needed
										UpperCAmelCase__       						=		{}
										if dropout_rng is not None:
																UpperCAmelCase__       						=		dropout_rng

										return self.module.apply(
										    {"""params""": params or self.params}							,     jnp.array(a__							,     dtype="""i4"""  )							,     jnp.array(a__							,     dtype=jnp.floataa  )							,     jnp.array(a__							,     dtype="""i4"""  )							,     jnp.array(a__							,     dtype="""i4"""  )							,     jnp.array(a__							,     dtype="""i4"""  )							,     not train							,     a__							,     a__							,     a__							,     rngs=a__							,     )

				def 							A			(  self							:     str							,     _lowercase							:     Tuple							,     _lowercase							:     int=None							,     _lowercase							:     Union[str, Any]=None							,     _lowercase							:     List[str]=None							,     _lowercase							:     Any = None							,     _lowercase							:     Optional[Any] = None							,     _lowercase							:     Optional[int]=False							,     ):


										'''simple docstring'''
										if position_ids is None:
																UpperCAmelCase__       						=		jnp.broadcast_to(jnp.arange(jnp.atleast_ad(a__  ).shape[-1]  )							,     input_ids.shape  )

										if token_type_ids is None:
																UpperCAmelCase__       						=		jnp.zeros_like(a__  )

										if attention_mask is None:
																UpperCAmelCase__       						=		jnp.ones_like(a__  )

										# Handle any PRNG if needed
										UpperCAmelCase__       						=		{}
										if dropout_rng is not None:
																UpperCAmelCase__       						=		dropout_rng

										def _get_features(_lowercase							:     List[str]							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     List[str]							,     _lowercase							:     Dict							,     _lowercase							:     List[Any]							,     _lowercase							:     List[str]  ):
																UpperCAmelCase__       						=		module.text_model(
																    input_ids=a__							,     attention_mask=a__							,     position_ids=a__							,     token_type_ids=a__							,     deterministic=a__							,     )
																UpperCAmelCase__       						=		text_outputs[1]
																UpperCAmelCase__       						=		module.text_projection(a__  )
																return text_features

										return self.module.apply(
										    {"""params""": params or self.params}							,     jnp.array(a__							,     dtype="""i4"""  )							,     jnp.array(a__							,     dtype="""i4"""  )							,     jnp.array(a__							,     dtype="""i4"""  )							,     jnp.array(a__							,     dtype="""i4"""  )							,     not train							,     method=_get_features							,     rngs=a__							,     )

				def 							A			(  self							:     Optional[int]							,     _lowercase							:     Optional[Any]							,     _lowercase							:     int = None							,     _lowercase							:     List[str] = None							,     _lowercase							:     Tuple=False  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		{}
										if dropout_rng is not None:
																UpperCAmelCase__       						=		dropout_rng

										def _get_features(_lowercase							:     Optional[Any]							,     _lowercase							:     Any							,     _lowercase							:     Optional[Any]  ):
																UpperCAmelCase__       						=		module.vision_model(pixel_values=a__							,     deterministic=a__  )
																UpperCAmelCase__       						=		vision_outputs[1]  # pooled_output
																UpperCAmelCase__       						=		module.visual_projection(a__  )
																return image_features

										return self.module.apply(
										    {"""params""": params or self.params}							,     jnp.array(a__							,     dtype=jnp.floataa  )							,     not train							,     method=_get_features							,     rngs=a__							,     )

				@classmethod
				def 							A			(  cls							:     Tuple							,     _lowercase							:     str = None							,     _lowercase							:     Optional[int] = None							,     *_lowercase							:     List[str]							,     **_lowercase							:     Optional[Any]							,     ):


										'''simple docstring'''
										UpperCAmelCase__       						=		{
										    argument[len("""text_"""  ) :]: value for argument, value in kwargs.items() if argument.startswith("""text_"""  )
										}

										UpperCAmelCase__       						=		{
										    argument[len("""vision_"""  ) :]: value for argument, value in kwargs.items() if argument.startswith("""vision_"""  )
										}

										# remove text, vision kwargs from kwargs
										for key in kwargs_text.keys():
																del kwargs["text_" + key]
										for key in kwargs_vision.keys():
																del kwargs["vision_" + key]

										# Load and initialize the text and vision model
										UpperCAmelCase__       						=		kwargs_text.pop("""model"""							,     a__  )
										if text_model is None:
																assert (
																    text_model_name_or_path is not None
																), "If `model` is not defined as an argument, a `text_model_name_or_path` has to be defined"
																from transformers import FlaxAutoModel

																if "config" not in kwargs_text:
																						from transformers import AutoConfig

																						UpperCAmelCase__       						=		AutoConfig.from_pretrained(a__  )
																						UpperCAmelCase__       						=		text_config

																UpperCAmelCase__       						=		FlaxAutoModel.from_pretrained(a__							,     *a__							,     **a__  )

										UpperCAmelCase__       						=		kwargs_vision.pop("""model"""							,     a__  )
										if vision_model is None:
																assert (
																    vision_model_name_or_path is not None
																), "If `model` is not defined as an argument, a `vision_model_name_or_path` has to be defined"
																from transformers import FlaxAutoModel

																if "config" not in kwargs_vision:
																						from transformers import AutoConfig

																						UpperCAmelCase__       						=		AutoConfig.from_pretrained(a__  )
																						UpperCAmelCase__       						=		vision_config

																UpperCAmelCase__       						=		FlaxAutoModel.from_pretrained(a__							,     *a__							,     **a__  )

										# instantiate config with corresponding kwargs
										UpperCAmelCase__       						=		kwargs.pop("""dtype"""							,     jnp.floataa  )
										UpperCAmelCase__       						=		HybridCLIPConfig.from_text_vision_configs(text_model.config							,     vision_model.config							,     **a__  )

										# init model
										UpperCAmelCase__       						=		cls(a__							,     *a__							,     dtype=a__							,     **a__  )

										if vision_config.model_type == "clip":
																UpperCAmelCase__       						=		vision_model.params["""vision_model"""]
																UpperCAmelCase__       						=		vision_model.params["""visual_projection"""]["""kernel"""]
										else:
																UpperCAmelCase__       						=		vision_model.params

										UpperCAmelCase__       						=		text_model.params

										return model



from ..utils import DummyObject, requires_backends

class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)







class 		__magic_name__				( metaclass=lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["vision"]


  def __init__(					self	,		*a__	,		**a__		):
    requires_backends(self	,		['''vision''']		)




