
def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   int:
       lowercase							:					Any	     =				1  # To kept the Calculated Value
       # Since C(n, k) = C(n, n-k)
       if k > (n - k):
              lowercase							:					Any	     =				n - k
       # Calculate C(n,k)
       for i in range(SCREAMING_SNAKE_CASE__    ):
              result *= n - i
              result //= i + 1
       return result







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   int:
       return binomial_coefficient(2 * node_count ,     SCREAMING_SNAKE_CASE__    ) // (node_count + 1)







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   int:
       if n < 0:
              raise ValueError("""factorial() not defined for negative values"""    )
       lowercase							:					Dict	     =				1
       for i in range(1 ,     n + 1    ):
              result *= i
       return result







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   int:
       return catalan_number(SCREAMING_SNAKE_CASE__    ) * factorial(SCREAMING_SNAKE_CASE__    )


if __name__ == "__main__":
  lowercase  : str						   =							int(input("""Enter the number of nodes: """).strip() or 0)
  if node_count <= 0:
    raise ValueError("""We need some nodes to work with.""")
  print(
      F'''Given {node_count} nodes, there are {binary_tree_count(node_count)} '''
      F'''binary trees and {catalan_number(node_count)} binary search trees.'''
  )


import os
import re
import sys
import traceback
import warnings
from pathlib import Path
from typing import Dict, Optional, Union
from uuid import uuida

from huggingface_hub import HfFolder, ModelCard, ModelCardData, hf_hub_download, whoami
from huggingface_hub.file_download import REGEX_COMMIT_HASH
from huggingface_hub.utils import (
    EntryNotFoundError,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    is_jinja_available,
)
from packaging import version
from requests import HTTPError

from .. import __version__
from .constants import (
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    SAFETENSORS_WEIGHTS_NAME,
    WEIGHTS_NAME,
)
from .import_utils import (
    ENV_VARS_TRUE_VALUES,
    _flax_version,
    _jax_version,
    _onnxruntime_version,
    _torch_version,
    is_flax_available,
    is_onnx_available,
    is_torch_available,
)
from .logging import get_logger


lowercase  : Tuple						   =							get_logger(__name__)


lowercase  : Optional[int]						   =							Path(__file__).parent / """model_card_template.md"""
lowercase  : Dict						   =							uuida().hex
lowercase  : Tuple						   =							os.getenv("""HF_HUB_OFFLINE""", """""").upper() in ENV_VARS_TRUE_VALUES
lowercase  : str						   =							os.getenv("""DISABLE_TELEMETRY""", """""").upper() in ENV_VARS_TRUE_VALUES
lowercase  : Tuple						   =							HUGGINGFACE_CO_RESOLVE_ENDPOINT + """/api/telemetry/"""







def 						_snake_case(  SCREAMING_SNAKE_CASE__ = None    )			->   str:
       lowercase							:					str	     =				f"diffusers/{__version__}; python/{sys.version.split()[0]}; session_id/{SESSION_ID}"
       if DISABLE_TELEMETRY or HF_HUB_OFFLINE:
              return ua + "; telemetry/off"
       if is_torch_available():
              ua += f"; torch/{_torch_version}"
       if is_flax_available():
              ua += f"; jax/{_jax_version}"
              ua += f"; flax/{_flax_version}"
       if is_onnx_available():
              ua += f"; onnxruntime/{_onnxruntime_version}"
       # CI will set this value to True
       if os.environ.get("""DIFFUSERS_IS_CI""" ,     """"""    ).upper() in ENV_VARS_TRUE_VALUES:
              ua += "; is_ci/true"
       if isinstance(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    ):
              ua += "; " + "; ".join(f"{k}/{v}" for k, v in user_agent.items()    )
       elif isinstance(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    ):
              ua += "; " + user_agent
       return ua







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ = None ,     SCREAMING_SNAKE_CASE__ = None    )			->   Dict:
       if token is None:
              lowercase							:					Optional[int]	     =				HfFolder.get_token()
       if organization is None:
              lowercase							:					int	     =				whoami(SCREAMING_SNAKE_CASE__    )["""name"""]
              return f"{username}/{model_id}"
       else:
              return f"{organization}/{model_id}"







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   Tuple:
       if not is_jinja_available():
              raise ValueError(
                  """Modelcard rendering is based on Jinja templates."""
                  """ Please make sure to have `jinja` installed before using `create_model_card`."""
                  """ To install it, please run `pip install Jinja2`."""    )

       if hasattr(SCREAMING_SNAKE_CASE__ ,     """local_rank"""    ) and args.local_rank not in [-1, 0]:
              return

       lowercase							:					str	     =				args.hub_token if hasattr(SCREAMING_SNAKE_CASE__ ,     """hub_token"""    ) else None
       lowercase							:					int	     =				get_full_repo_name(SCREAMING_SNAKE_CASE__ ,     token=SCREAMING_SNAKE_CASE__    )

       lowercase							:					Dict	     =				ModelCard.from_template(
           card_data=ModelCardData(  # Card metadata object that will be converted to YAML block
               language="""en""" ,     license="""apache-2.0""" ,     library_name="""diffusers""" ,     tags=[] ,     datasets=args.dataset_name ,     metrics=[] ,     ) ,     template_path=SCREAMING_SNAKE_CASE__ ,     model_name=SCREAMING_SNAKE_CASE__ ,     repo_name=SCREAMING_SNAKE_CASE__ ,     dataset_name=args.dataset_name if hasattr(SCREAMING_SNAKE_CASE__ ,     """dataset_name"""    ) else None ,     learning_rate=args.learning_rate ,     train_batch_size=args.train_batch_size ,     eval_batch_size=args.eval_batch_size ,     gradient_accumulation_steps=(
               args.gradient_accumulation_steps if hasattr(SCREAMING_SNAKE_CASE__ ,     """gradient_accumulation_steps"""    ) else None
           ) ,     adam_betaa=args.adam_betaa if hasattr(SCREAMING_SNAKE_CASE__ ,     """adam_beta1"""    ) else None ,     adam_betaa=args.adam_betaa if hasattr(SCREAMING_SNAKE_CASE__ ,     """adam_beta2"""    ) else None ,     adam_weight_decay=args.adam_weight_decay if hasattr(SCREAMING_SNAKE_CASE__ ,     """adam_weight_decay"""    ) else None ,     adam_epsilon=args.adam_epsilon if hasattr(SCREAMING_SNAKE_CASE__ ,     """adam_epsilon"""    ) else None ,     lr_scheduler=args.lr_scheduler if hasattr(SCREAMING_SNAKE_CASE__ ,     """lr_scheduler"""    ) else None ,     lr_warmup_steps=args.lr_warmup_steps if hasattr(SCREAMING_SNAKE_CASE__ ,     """lr_warmup_steps"""    ) else None ,     ema_inv_gamma=args.ema_inv_gamma if hasattr(SCREAMING_SNAKE_CASE__ ,     """ema_inv_gamma"""    ) else None ,     ema_power=args.ema_power if hasattr(SCREAMING_SNAKE_CASE__ ,     """ema_power"""    ) else None ,     ema_max_decay=args.ema_max_decay if hasattr(SCREAMING_SNAKE_CASE__ ,     """ema_max_decay"""    ) else None ,     mixed_precision=args.mixed_precision ,     )

       lowercase							:					str	     =				os.path.join(args.output_dir ,     """README.md"""    )
       model_card.save(SCREAMING_SNAKE_CASE__    )







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ = None    )			->   Optional[Any]:
       if resolved_file is None or commit_hash is not None:
              return commit_hash
       lowercase							:					List[Any]	     =				str(Path(SCREAMING_SNAKE_CASE__    ).as_posix()    )
       lowercase							:					Any	     =				re.search(R"""snapshots/([^/]+)/""" ,     SCREAMING_SNAKE_CASE__    )
       if search is None:
              return None
       lowercase							:					List[Any]	     =				search.groups()[0]
       return commit_hash if REGEX_COMMIT_HASH.match(SCREAMING_SNAKE_CASE__    ) else None


# Old default cache path, potentially to be migrated.
# This logic was more or less taken from `transformers`, with the following differences:
# - Diffusers doesn't use custom environment variables to specify the cache path.
# - There is no need to migrate the cache format, just move the files to the new location.
lowercase  : Optional[Any]						   =							os.path.expanduser(
    os.getenv("""HF_HOME""", os.path.join(os.getenv("""XDG_CACHE_HOME""", """~/.cache"""), """huggingface"""))
)
lowercase  : Optional[int]						   =							os.path.join(hf_cache_home, """diffusers""")







def 						_snake_case(  SCREAMING_SNAKE_CASE__ = None ,     SCREAMING_SNAKE_CASE__ = None    )			->   None:
       if new_cache_dir is None:
              lowercase							:					Union[str, Any]	     =				DIFFUSERS_CACHE
       if old_cache_dir is None:
              lowercase							:					List[str]	     =				old_diffusers_cache

       lowercase							:					Dict	     =				Path(SCREAMING_SNAKE_CASE__    ).expanduser()
       lowercase							:					int	     =				Path(SCREAMING_SNAKE_CASE__    ).expanduser()
       for old_blob_path in old_cache_dir.glob("""**/blobs/*"""    ):
              if old_blob_path.is_file() and not old_blob_path.is_symlink():
                     lowercase							:					Any	     =				new_cache_dir / old_blob_path.relative_to(SCREAMING_SNAKE_CASE__    )
                     new_blob_path.parent.mkdir(parents=SCREAMING_SNAKE_CASE__ ,     exist_ok=SCREAMING_SNAKE_CASE__    )
                     os.replace(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )
                     try:
                            os.symlink(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )
                     except OSError:
                            logger.warning(
                                """Could not create symlink between old cache and new cache. If you use an older version of diffusers again, files will be re-downloaded."""    )
       # At this point, old_cache_dir contains symlinks to the new cache (it can still be used).


lowercase  : Dict						   =							os.path.join(DIFFUSERS_CACHE, """version_diffusers_cache.txt""")
if not os.path.isfile(cache_version_file):
  lowercase  : Any						   =							0
else:
  with open(cache_version_file) as f:
    try:
      lowercase  : List[Any]						   =							int(f.read())
    except ValueError:
      lowercase  : int						   =							0

if cache_version < 1:
  lowercase  : Union[str, Any]						   =							os.path.isdir(old_diffusers_cache) and len(os.listdir(old_diffusers_cache)) > 0
  if old_cache_is_not_empty:
    logger.warning(
        """The cache for model files in Diffusers v0.14.0 has moved to a new location. Moving your """
        """existing cached models. This is a one-time operation, you can interrupt it or run it """
        """later by calling `diffusers.utils.hub_utils.move_cache()`."""
    )
    try:
      move_cache()
    except Exception as e:
      lowercase  : int						   =							"""\n""".join(traceback.format_tb(e.__traceback__))
      logger.error(
          F'''There was a problem when trying to move your cache:\n\n{trace}\n{e.__class__.__name__}: {e}\n\nPlease '''
          """file an issue at https://github.com/huggingface/diffusers/issues/new/choose, copy paste this whole """
          """message and we will do our best to help."""
      )

if cache_version < 1:
  try:
    os.makedirs(DIFFUSERS_CACHE, exist_ok=True)
    with open(cache_version_file, """w""") as f:
      f.write("""1""")
  except Exception:
    logger.warning(
        F'''There was a problem when trying to write in your cache folder ({DIFFUSERS_CACHE}). Please, ensure '''
        """the directory exists and can be written to."""
    )







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ = None    )			->   str:
       if variant is not None:
              lowercase							:					List[str]	     =				weights_name.split("""."""    )
              lowercase							:					Optional[Any]	     =				splits[:-1] + [variant] + splits[-1:]
              lowercase							:					int	     =				""".""".join(SCREAMING_SNAKE_CASE__    )

       return weights_name







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     *,
    SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__=None ,     )			->   Optional[Any]:
       lowercase							:					Optional[int]	     =				str(SCREAMING_SNAKE_CASE__    )
       if os.path.isfile(SCREAMING_SNAKE_CASE__    ):
              return pretrained_model_name_or_path
       elif os.path.isdir(SCREAMING_SNAKE_CASE__    ):
              if os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )    ):
                     # Load from a PyTorch checkpoint
                     lowercase							:					List[Any]	     =				os.path.join(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )
                     return model_file
              elif subfolder is not None and os.path.isfile(
                  os.path.join(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )    ):
                     lowercase							:					Any	     =				os.path.join(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )
                     return model_file
              else:
                     raise EnvironmentError(
                         f"Error no file named {weights_name} found in directory {pretrained_model_name_or_path}."    )
       else:
              # 1. First check if deprecated way of loading from branches is used
              if (
                  revision in DEPRECATED_REVISION_ARGS
                  and (weights_name == WEIGHTS_NAME or weights_name == SAFETENSORS_WEIGHTS_NAME)
                  and version.parse(version.parse(SCREAMING_SNAKE_CASE__    ).base_version    ) >= version.parse("""0.20.0"""    )
              ):
                     try:
                            lowercase							:					Any	     =				hf_hub_download(
                                SCREAMING_SNAKE_CASE__ ,     filename=_add_variant(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    ) ,     cache_dir=SCREAMING_SNAKE_CASE__ ,     force_download=SCREAMING_SNAKE_CASE__ ,     proxies=SCREAMING_SNAKE_CASE__ ,     resume_download=SCREAMING_SNAKE_CASE__ ,     local_files_only=SCREAMING_SNAKE_CASE__ ,     use_auth_token=SCREAMING_SNAKE_CASE__ ,     user_agent=SCREAMING_SNAKE_CASE__ ,     subfolder=SCREAMING_SNAKE_CASE__ ,     revision=revision or commit_hash ,     )
                            warnings.warn(
                                f"Loading the variant {revision} from {pretrained_model_name_or_path} via `revision='{revision}'` is deprecated. Loading instead from `revision='main'` with `variant={revision}`. Loading model variants via `revision='{revision}'` will be removed in diffusers v1. Please use `variant='{revision}'` instead." ,     SCREAMING_SNAKE_CASE__ ,     )
                            return model_file
                     except:  # noqa: E722
                            warnings.warn(
                                f"You are loading the variant {revision} from {pretrained_model_name_or_path} via `revision='{revision}'`. This behavior is deprecated and will be removed in diffusers v1. One should use `variant='{revision}'` instead. However, it appears that {pretrained_model_name_or_path} currently does not have a {_add_variant(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )} file in the 'main' branch of {pretrained_model_name_or_path}. \n The Diffusers team and community would be very grateful if you could open an issue: https://github.com/huggingface/diffusers/issues/new with the title '{pretrained_model_name_or_path} is missing {_add_variant(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )}' so that the correct variant file can be added." ,     SCREAMING_SNAKE_CASE__ ,     )
              try:
                     # 2. Load model file as usual
                     lowercase							:					int	     =				hf_hub_download(
                         SCREAMING_SNAKE_CASE__ ,     filename=SCREAMING_SNAKE_CASE__ ,     cache_dir=SCREAMING_SNAKE_CASE__ ,     force_download=SCREAMING_SNAKE_CASE__ ,     proxies=SCREAMING_SNAKE_CASE__ ,     resume_download=SCREAMING_SNAKE_CASE__ ,     local_files_only=SCREAMING_SNAKE_CASE__ ,     use_auth_token=SCREAMING_SNAKE_CASE__ ,     user_agent=SCREAMING_SNAKE_CASE__ ,     subfolder=SCREAMING_SNAKE_CASE__ ,     revision=revision or commit_hash ,     )
                     return model_file

              except RepositoryNotFoundError:
                     raise EnvironmentError(
                         f"{pretrained_model_name_or_path} is not a local folder and is not a valid model identifier "
                         """listed on 'https://huggingface.co/models'\nIf this is a private repository, make sure to pass a """
                         """token having permission to this repo with `use_auth_token` or log in with `huggingface-cli """
                         """login`."""    )
              except RevisionNotFoundError:
                     raise EnvironmentError(
                         f"{revision} is not a valid git identifier (branch name, tag name or commit id) that exists for "
                         """this model name. Check the model page at """
                         f"'https://huggingface.co/{pretrained_model_name_or_path}' for available revisions."    )
              except EntryNotFoundError:
                     raise EnvironmentError(
                         f"{pretrained_model_name_or_path} does not appear to have a file named {weights_name}."    )
              except HTTPError as err:
                     raise EnvironmentError(
                         f"There was a specific connection error when trying to load {pretrained_model_name_or_path}:\n{err}"    )
              except ValueError:
                     raise EnvironmentError(
                         f"We couldn't connect to '{HUGGINGFACE_CO_RESOLVE_ENDPOINT}' to load this model, couldn't find it"
                         f" in the cached files and it looks like {pretrained_model_name_or_path} is not the path to a"
                         f" directory containing a file named {weights_name} or"
                         """ \nCheckout your internet connection or see how to run the library in"""
                         """ offline mode at 'https://huggingface.co/docs/diffusers/installation#offline-mode'."""    )
              except EnvironmentError:
                     raise EnvironmentError(
                         f"Can't load the model for '{pretrained_model_name_or_path}'. If you were trying to load it from "
                         """'https://huggingface.co/models', make sure you don't have a local directory with the same name. """
                         f"Otherwise, make sure '{pretrained_model_name_or_path}' is the correct path to a directory "
                         f"containing a file named {weights_name}"    )
