
def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    int:
       if divisor % 5 == 0 or divisor % 2 == 0:
              return 0
       lowercase							:     str       	=      1
       lowercase							:     str       	=      1
       while repunit:
              lowercase							:     Tuple       	=      (10 * repunit + 1) % divisor
              repunit_index += 1
       return repunit_index







def 						_snake_case(  SCREAMING_SNAKE_CASE__ = 1_000_000				) ->    int:
       lowercase							:     List[Any]       	=      limit - 1
       if divisor % 2 == 0:
              divisor += 1
       while least_divisible_repunit(SCREAMING_SNAKE_CASE__				) <= limit:
              divisor += 2
       return divisor


if __name__ == "__main__":
  print(F'''{solution() = }''')


from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
  from PIL import Image

  from ..image_utils import load_image

if is_tf_available():
  import tensorflow as tf

  from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
  from ..tf_utils import stable_softmax

if is_torch_available():
  from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING

lowercase  :					Any						    =							logging.get_logger(__name__)

@add_end_docstrings(lowerCAmelCase     )
class __snake_case		(      lowerCAmelCase     ):
    def __init__(  self		,*snake_case		,**snake_case      ):



           '''simple docstring'''







           super().__init__(*snake_case		,**snake_case      )
           requires_backends(self		,"""vision"""      )
           self.check_model_type(
               TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
               if self.framework == """tf"""
               else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING      )
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case=None      ):



           '''simple docstring'''







           lowercase							:     List[Any]       	=      {}
           if top_k is not None:
                  lowercase							:     int       	=      top_k
           return {}, {}, postprocess_params
    def __call__(  self		,snake_case		,**snake_case      ):



           '''simple docstring'''







           return super().__call__(snake_case		,**snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case      ):



           '''simple docstring'''







           lowercase							:     Any       	=      load_image(snake_case      )
           lowercase							:     List[Any]       	=      self.image_processor(images=snake_case		,return_tensors=self.framework      )
           return model_inputs
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case      ):



           '''simple docstring'''







           lowercase							:     int       	=      self.model(**snake_case      )
           return model_outputs
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case=5      ):



           '''simple docstring'''







           if top_k > self.model.config.num_labels:
                  lowercase							:     Tuple       	=      self.model.config.num_labels

           if self.framework == "pt":
                  lowercase							:     str       	=      model_outputs.logits.softmax(-1      )[0]
                  lowercase	,			lowercase							:     Dict       	=      probs.topk(snake_case      )
           elif self.framework == "tf":
                  lowercase							:     Optional[int]       	=      stable_softmax(model_outputs.logits		,axis=-1      )[0]
                  lowercase							:     Union[str, Any]       	=      tf.math.top_k(snake_case		,k=snake_case      )
                  lowercase	,			lowercase							:     List[str]       	=      topk.values.numpy(), topk.indices.numpy()
           else:
                  raise ValueError(f"Unsupported framework: {self.framework}"      )

           lowercase							:     Tuple       	=      scores.tolist()
           lowercase							:     Dict       	=      ids.tolist()
           return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(snake_case		,snake_case      )]
