
import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import Mock, patch

import diffusers.utils.hub_utils


class   __lowerCAmelCase		(		unittest.TestCase ):



      """simple docstring"""







      @patch('''diffusers.utils.hub_utils.get_full_repo_name'''			)
      def 						snake_case_     ( self						:    Optional[Any]			,    _snake_case						:    Mock			):
          __lowercase						:     Dict		      =    '''full_repo_name'''
          with TemporaryDirectory() as tmpdir:
              # Dummy args values
              __lowercase						:     List[str]		      =    Mock()
              __lowercase						:     Union[str, Any]		      =    tmpdir
              __lowercase						:     Optional[Any]		      =    0
              __lowercase						:     Dict		      =    '''hub_token'''
              __lowercase						:     Any		      =    '''dataset_name'''
              __lowercase						:     Tuple		      =    0.01
              __lowercase						:     List[Any]		      =    10_0000
              __lowercase						:     int		      =    1_0000
              __lowercase						:     Optional[Any]		      =    0.01
              __lowercase						:     Optional[int]		      =    0.02
              __lowercase						:     Dict		      =    0.03
              __lowercase						:     str		      =    0.00_05
              __lowercase						:     str		      =    0.00_00_01
              __lowercase						:     int		      =    1
              __lowercase						:     int		      =    10
              __lowercase						:     Union[str, Any]		      =    0.0_01
              __lowercase						:     str		      =    0.1
              __lowercase						:     Dict		      =    0.2
              __lowercase						:     int		      =    True

              # Model card mush be rendered and saved
              diffusers.utils.hub_utils.create_model_card(_snake_case			,    model_name='''model_name'''			)
              self.assertTrue((Path(_snake_case			) / '''README.md''').is_file()			)




from __future__ import annotations

from collections import Counter


def       UpperCAmelCase_					(  __lowerCAmelCase		)	->  list[int]:
    __lowercase						:     Any		      =    [True] * n
    __lowercase						:     str		      =    False
    __lowercase						:     int		      =    False
    __lowercase						:     List[Any]		      =    True

    for i in range(3		,   int(n**0.5 + 1		)		,   2		):
        __lowercase						:     List[str]		      =    i * 2
        while index < n:
            __lowercase						:     List[Any]		      =    False
            __lowercase						:     Dict		      =    index + i

    __lowercase						:     Tuple		      =    [2]

    for i in range(3		,   __lowerCAmelCase		,   2		):
        if is_prime[i]:
            primes.append(__lowerCAmelCase		)

    return primes


def       UpperCAmelCase_					(  __lowerCAmelCase		)	->  list[list[int]]:
    __lowercase						:     Optional[int]		      =    str(__lowerCAmelCase		)
    __lowercase						:     List[str]		      =    []
    __lowercase						:     int		      =    ['''0''', '''1''', '''2''', '''3''', '''4''', '''5''', '''6''', '''7''', '''8''', '''9''']

    for duplicate in Counter(__lowerCAmelCase		) - Counter(set(__lowerCAmelCase		)		):
        __lowercase						:     Union[str, Any]		      =    [int(number_str.replace(__lowerCAmelCase		,   __lowerCAmelCase		)		) for digit in digits]
        replacements.append(__lowerCAmelCase		)

    return replacements


def       UpperCAmelCase_					(  __lowerCAmelCase = 8		)	->  int:
    __lowercase						:     Tuple		      =    set()

    # Filter primes with less than 3 replaceable digits
    __lowercase						:     int		      =    {
        x for x in set(prime_sieve(1_000_000		)		) if len(str(__lowerCAmelCase		)		) - len(set(str(__lowerCAmelCase		)		)		) >= 3
    }

    for prime in primes:
        if prime in numbers_checked:
            continue

        __lowercase						:     str		      =    digit_replacements(__lowerCAmelCase		)

        for family in replacements:
            numbers_checked.update(__lowerCAmelCase		)
            __lowercase						:     List[Any]		      =    primes.intersection(__lowerCAmelCase		)

            if len(__lowerCAmelCase		) != family_length:
                continue

            return min(__lowerCAmelCase		)

    return -1


if __name__ == "__main__":
 print(solution())


