
import importlib
import inspect
import json
import os
import re
import shutil
import sys
from pathlib import Path
from typing import Dict, Optional, Union
from urllib import request

from huggingface_hub import HfFolder, cached_download, hf_hub_download, model_info
from packaging import version

from .. import __version__
from . import DIFFUSERS_DYNAMIC_MODULE_NAME, HF_MODULES_CACHE, logging


__magic_name__  							=	(
    '''https://raw.githubusercontent.com/huggingface/diffusers/{revision}/examples/community/{pipeline}.py'''
)


__magic_name__  							=	logging.get_logger(__name__)  # pylint: disable=invalid-name





def 						SCREAMING_SNAKE_CASE__     (   ):
    snake_case__    =					"https://pypi.org/pypi/diffusers/json"
    snake_case__    =					json.loads(request.urlopen(__lowerCAmelCase				).read()				)["releases"].keys()
    return sorted(__lowerCAmelCase     ,		key=lambda __lowerCAmelCase				: version.Version(__lowerCAmelCase				)				)





def 						SCREAMING_SNAKE_CASE__     (   ):
    # This function has already been executed if HF_MODULES_CACHE already is in the Python path.
    if HF_MODULES_CACHE in sys.path:
        return

    sys.path.append(__lowerCAmelCase				)
    os.makedirs(__lowerCAmelCase     ,		exist_ok=__lowerCAmelCase				)
    snake_case__    =					Path(__lowerCAmelCase				) / "__init__.py"
    if not init_path.exists():
        init_path.touch()





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    init_hf_modules()
    snake_case__    =					Path(__lowerCAmelCase				) / name
    # If the parent module does not exist yet, recursively create it.
    if not dynamic_module_path.parent.exists():
        create_dynamic_module(dynamic_module_path.parent				)
    os.makedirs(__lowerCAmelCase     ,		exist_ok=__lowerCAmelCase				)
    snake_case__    =					dynamic_module_path / "__init__.py"
    if not init_path.exists():
        init_path.touch()





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    with open(__lowerCAmelCase     ,		"r"     ,		encoding="utf-8"				) as f:
        snake_case__    =					f.read()

    # Imports of the form `import .xxx`
    snake_case__    =					re.findall("^\s*import\s+\.(\S+)\s*$"     ,		__lowerCAmelCase     ,		flags=re.MULTILINE				)
    # Imports of the form `from .xxx import yyy`
    relative_imports += re.findall("^\s*from\s+\.(\S+)\s+import"     ,		__lowerCAmelCase     ,		flags=re.MULTILINE				)
    # Unique-ify
    return list(set(__lowerCAmelCase				)				)





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    snake_case__    =					False
    snake_case__    =					[module_file]
    snake_case__    =					[]

    # Let's recurse through all relative imports
    while not no_change:
        snake_case__    =					[]
        for f in files_to_check:
            new_imports.extend(get_relative_imports(__lowerCAmelCase				)				)

        snake_case__    =					Path(__lowerCAmelCase				).parent
        snake_case__    =					[str(module_path / m				) for m in new_imports]
        snake_case__    =					[f for f in new_import_files if f not in all_relative_imports]
        snake_case__    =					[F"""{f}.py""" for f in new_import_files]

        snake_case__    =					len(__lowerCAmelCase				) == 0
        all_relative_imports.extend(__lowerCAmelCase				)

    return all_relative_imports





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    with open(__lowerCAmelCase     ,		"r"     ,		encoding="utf-8"				) as f:
        snake_case__    =					f.read()

    # Imports of the form `import xxx`
    snake_case__    =					re.findall("^\s*import\s+(\S+)\s*$"     ,		__lowerCAmelCase     ,		flags=re.MULTILINE				)
    # Imports of the form `from xxx import yyy`
    imports += re.findall("^\s*from\s+(\S+)\s+import"     ,		__lowerCAmelCase     ,		flags=re.MULTILINE				)
    # Only keep the top-level module
    snake_case__    =					[imp.split("."				)[0] for imp in imports if not imp.startswith("."				)]

    # Unique-ify and test we got them all
    snake_case__    =					list(set(__lowerCAmelCase				)				)
    snake_case__    =					[]
    for imp in imports:
        try:
            importlib.import_module(__lowerCAmelCase				)
        except ImportError:
            missing_packages.append(__lowerCAmelCase				)

    if len(__lowerCAmelCase				) > 0:
        raise ImportError(
            "This modeling file requires the following packages that were not found in your environment: "
            F"""{", ".join(__lowerCAmelCase				)}. Run `pip install {" ".join(__lowerCAmelCase				)}`"""				)

    return get_relative_imports(__lowerCAmelCase				)





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase     ,		__lowerCAmelCase				):
    snake_case__    =					module_path.replace(os.path.sep     ,		"."				)
    snake_case__    =					importlib.import_module(__lowerCAmelCase				)

    if class_name is None:
        return find_pipeline_class(__lowerCAmelCase				)
    return getattr(__lowerCAmelCase     ,		__lowerCAmelCase				)





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    from ..pipelines import DiffusionPipeline

    snake_case__    =					dict(inspect.getmembers(__lowerCAmelCase     ,		inspect.isclass				)				)

    snake_case__    =					None
    for cls_name, cls in cls_members.items():
        if (
            cls_name != DiffusionPipeline.__name__
            and issubclass(cls     ,		__lowerCAmelCase				)
            and cls.__module__.split("."				)[0] != "diffusers"
        ):
            if pipeline_class is not None:
                raise ValueError(
                    F"""Multiple classes that inherit from {DiffusionPipeline.__name__} have been found:"""
                    F""" {pipeline_class.__name__}, and {cls_name}. Please make sure to define only one in"""
                    F""" {loaded_module}."""				)
            snake_case__    =					cls

    return pipeline_class





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase     ,		__lowerCAmelCase     ,		__lowerCAmelCase = None     ,		__lowerCAmelCase = False     ,		__lowerCAmelCase = False     ,		__lowerCAmelCase = None     ,		__lowerCAmelCase = None     ,		__lowerCAmelCase = None     ,		__lowerCAmelCase = False     ,		):
    snake_case__    =					str(__lowerCAmelCase				)

    snake_case__    =					os.path.join(__lowerCAmelCase     ,		__lowerCAmelCase				)

    if os.path.isfile(__lowerCAmelCase				):
        snake_case__    =					module_file_or_url
        snake_case__    =					"local"
    elif pretrained_model_name_or_path.count("/"				) == 0:
        snake_case__    =					get_diffusers_versions()
        # cut ".dev0"
        snake_case__    =					"v" + ".".join(__version__.split("."				)[:3]				)

        # retrieve github version that matches
        if revision is None:
            snake_case__    =					latest_version if latest_version[1:] in available_versions else "main"
            logger.info(F"""Defaulting to latest_version: {revision}."""				)
        elif revision in available_versions:
            snake_case__    =					F"""v{revision}"""
        elif revision == "main":
            snake_case__    =					revision
        else:
            raise ValueError(
                F"""`custom_revision`: {revision} does not exist. Please make sure to choose one of"""
                F""" {", ".join(available_versions + ["main"]				)}."""				)

        # community pipeline on GitHub
        snake_case__    =					COMMUNITY_PIPELINES_URL.format(revision=__lowerCAmelCase     ,		pipeline=__lowerCAmelCase				)
        try:
            snake_case__    =					cached_download(
                __lowerCAmelCase     ,		cache_dir=__lowerCAmelCase     ,		force_download=__lowerCAmelCase     ,		proxies=__lowerCAmelCase     ,		resume_download=__lowerCAmelCase     ,		local_files_only=__lowerCAmelCase     ,		use_auth_token=__lowerCAmelCase     ,		)
            snake_case__    =					"git"
            snake_case__    =					pretrained_model_name_or_path + ".py"
        except EnvironmentError:
            logger.error(F"""Could not locate the {module_file} inside {pretrained_model_name_or_path}."""				)
            raise
    else:
        try:
            # Load from URL or cache if already cached
            snake_case__    =					hf_hub_download(
                __lowerCAmelCase     ,		__lowerCAmelCase     ,		cache_dir=__lowerCAmelCase     ,		force_download=__lowerCAmelCase     ,		proxies=__lowerCAmelCase     ,		resume_download=__lowerCAmelCase     ,		local_files_only=__lowerCAmelCase     ,		use_auth_token=__lowerCAmelCase     ,		)
            snake_case__    =					os.path.join("local"     ,		"--".join(pretrained_model_name_or_path.split("/"				)				)				)
        except EnvironmentError:
            logger.error(F"""Could not locate the {module_file} inside {pretrained_model_name_or_path}."""				)
            raise

    # Check we have all the requirements in our environment
    snake_case__    =					check_imports(__lowerCAmelCase				)

    # Now we move the module inside our cached dynamic modules.
    snake_case__    =					DIFFUSERS_DYNAMIC_MODULE_NAME + os.path.sep + submodule
    create_dynamic_module(__lowerCAmelCase				)
    snake_case__    =					Path(__lowerCAmelCase				) / full_submodule
    if submodule == "local" or submodule == "git":
        # We always copy local files (we could hash the file to see if there was a change, and give them the name of
        # that hash, to only copy when there is a modification but it seems overkill for now).
        # The only reason we do the copy is to avoid putting too many folders in sys.path.
        shutil.copy(__lowerCAmelCase     ,		submodule_path / module_file				)
        for module_needed in modules_needed:
            snake_case__    =					F"""{module_needed}.py"""
            shutil.copy(os.path.join(__lowerCAmelCase     ,		__lowerCAmelCase				)     ,		submodule_path / module_needed				)
    else:
        # Get the commit hash
        # TODO: we will get this info in the etag soon, so retrieve it from there and not here.
        if isinstance(__lowerCAmelCase     ,		__lowerCAmelCase				):
            snake_case__    =					use_auth_token
        elif use_auth_token is True:
            snake_case__    =					HfFolder.get_token()
        else:
            snake_case__    =					None

        snake_case__    =					model_info(__lowerCAmelCase     ,		revision=__lowerCAmelCase     ,		token=__lowerCAmelCase				).sha

        # The module file will end up being placed in a subfolder with the git hash of the repo. This way we get the
        # benefit of versioning.
        snake_case__    =					submodule_path / commit_hash
        snake_case__    =					full_submodule + os.path.sep + commit_hash
        create_dynamic_module(__lowerCAmelCase				)

        if not (submodule_path / module_file).exists():
            shutil.copy(__lowerCAmelCase     ,		submodule_path / module_file				)
        # Make sure we also have every file with relative
        for module_needed in modules_needed:
            if not (submodule_path / module_needed).exists():
                get_cached_module_file(
                    __lowerCAmelCase     ,		F"""{module_needed}.py"""     ,		cache_dir=__lowerCAmelCase     ,		force_download=__lowerCAmelCase     ,		resume_download=__lowerCAmelCase     ,		proxies=__lowerCAmelCase     ,		use_auth_token=__lowerCAmelCase     ,		revision=__lowerCAmelCase     ,		local_files_only=__lowerCAmelCase     ,		)
    return os.path.join(__lowerCAmelCase     ,		__lowerCAmelCase				)





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase     ,		__lowerCAmelCase     ,		__lowerCAmelCase = None     ,		__lowerCAmelCase = None     ,		__lowerCAmelCase = False     ,		__lowerCAmelCase = False     ,		__lowerCAmelCase = None     ,		__lowerCAmelCase = None     ,		__lowerCAmelCase = None     ,		__lowerCAmelCase = False     ,		**__lowerCAmelCase     ,		):
    snake_case__    =					get_cached_module_file(
        __lowerCAmelCase     ,		__lowerCAmelCase     ,		cache_dir=__lowerCAmelCase     ,		force_download=__lowerCAmelCase     ,		resume_download=__lowerCAmelCase     ,		proxies=__lowerCAmelCase     ,		use_auth_token=__lowerCAmelCase     ,		revision=__lowerCAmelCase     ,		local_files_only=__lowerCAmelCase     ,		)
    return get_class_in_module(__lowerCAmelCase     ,		final_module.replace(".py"     ,		""				)				)





import math

__magic_name__  							=	10
__magic_name__  							=	7
__magic_name__  							=	BALLS_PER_COLOUR * NUM_COLOURS





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase = 20				):
    snake_case__    =					math.comb(__lowerCAmelCase     ,		__lowerCAmelCase				)
    snake_case__    =					math.comb(NUM_BALLS - BALLS_PER_COLOUR     ,		__lowerCAmelCase				)

    snake_case__    =					NUM_COLOURS * (1 - missing_colour / total)

    return F"""{result:.9f}"""


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



