





"""simple docstring"""





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


__A											=		get_logger(__name__)


__A											=		Path(__file__).parent / """model_card_template.md"""
__A											=		uuida().hex
__A											=		os.getenv("""HF_HUB_OFFLINE""", """""").upper() in ENV_VARS_TRUE_VALUES
__A											=		os.getenv("""DISABLE_TELEMETRY""", """""").upper() in ENV_VARS_TRUE_VALUES
__A											=		HUGGINGFACE_CO_RESOLVE_ENDPOINT + """/api/telemetry/"""
def  __A   (_SCREAMING_SNAKE_CASE = None			)					->str:





  """simple docstring"""


  lowerCAmelCase__			:List[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  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE = None     ,   _SCREAMING_SNAKE_CASE = None			)					->int:





  """simple docstring"""


  if token is None:
    lowerCAmelCase__			:Optional[int]											=							HfFolder.get_token()
  if organization is None:
    lowerCAmelCase__			:Optional[int]											=							whoami(_SCREAMING_SNAKE_CASE			)['name']
    return F"{username}/{model_id}"
  else:
    return F"{organization}/{model_id}"
def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)					->Union[str, Any]:





  """simple docstring"""


  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

  lowerCAmelCase__			:Optional[Any]											=							args.hub_token if hasattr(_SCREAMING_SNAKE_CASE     ,   'hub_token'			) else None
  lowerCAmelCase__			:Tuple											=							get_full_repo_name(_SCREAMING_SNAKE_CASE     ,   token=_SCREAMING_SNAKE_CASE			)

  lowerCAmelCase__			:Tuple											=							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     ,   )

  lowerCAmelCase__			:Tuple											=							os.path.join(args.output_dir     ,   'README.md'			)
  model_card.save(_SCREAMING_SNAKE_CASE			)
def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE = None			)					->int:





  """simple docstring"""


  if resolved_file is None or commit_hash is not None:
    return commit_hash
  lowerCAmelCase__			:Any											=							str(Path(_SCREAMING_SNAKE_CASE			).as_posix()			)
  lowerCAmelCase__			:int											=							re.search(r'snapshots/([^/]+)/'     ,   _SCREAMING_SNAKE_CASE			)
  if search is None:
    return None
  lowerCAmelCase__			: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.
__A											=		os.path.expanduser(
    os.getenv("""HF_HOME""", os.path.join(os.getenv("""XDG_CACHE_HOME""", """~/.cache"""), """huggingface"""))
)
__A											=		os.path.join(hf_cache_home, """diffusers""")
def  __A   (_SCREAMING_SNAKE_CASE = None     ,   _SCREAMING_SNAKE_CASE = None			)					->None:





  """simple docstring"""


  if new_cache_dir is None:
    lowerCAmelCase__			:Optional[Any]											=							DIFFUSERS_CACHE
  if old_cache_dir is None:
    lowerCAmelCase__			:Tuple											=							old_diffusers_cache

  lowerCAmelCase__			:Optional[int]											=							Path(_SCREAMING_SNAKE_CASE			).expanduser()
  lowerCAmelCase__			: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():
      lowerCAmelCase__			: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).


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

if cache_version < 1:
  __A											=		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:
      __A											=		"""\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  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE = None			)					->str:





  """simple docstring"""


  if variant is not None:
    lowerCAmelCase__			:int											=							weights_name.split('.'			)
    lowerCAmelCase__			:Optional[Any]											=							splits[:-1] + [variant] + splits[-1:]
    lowerCAmelCase__			:Tuple											=							'.'.join(_SCREAMING_SNAKE_CASE			)

  return weights_name




def  __A   (_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     ,   )					->Dict:





  """simple docstring"""


  lowerCAmelCase__			:Optional[Any]											=							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
      lowerCAmelCase__			:int											=							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			)			):
      lowerCAmelCase__			:Dict											=							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:
        lowerCAmelCase__			:Optional[int]											=							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
      lowerCAmelCase__			: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}"			)







"""simple docstring"""





from multiprocessing import Lock, Pipe, Process

# lock used to ensure that two processes do not access a pipe at the same time
__A											=		Lock()
def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)					->List[Any]:





  """simple docstring"""


  global process_lock

  # we perform n swaps since after n swaps we know we are sorted
  # we *could* stop early if we are sorted already, but it takes as long to
  # find out we are sorted as it does to sort the list with this algorithm
  for i in range(0     ,   10			):
    if (i + position) % 2 == 0 and r_send is not None:
      # send your value to your right neighbor
      process_lock.acquire()
      r_send[1].send(_SCREAMING_SNAKE_CASE			)
      process_lock.release()

      # receive your right neighbor's value
      process_lock.acquire()
      lowerCAmelCase__			:Any											=							rr_cv[0].recv()
      process_lock.release()

      # take the lower value since you are on the left
      lowerCAmelCase__			:Tuple											=							min(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)
    elif (i + position) % 2 != 0 and l_send is not None:
      # send your value to your left neighbor
      process_lock.acquire()
      l_send[1].send(_SCREAMING_SNAKE_CASE			)
      process_lock.release()

      # receive your left neighbor's value
      process_lock.acquire()
      lowerCAmelCase__			:Optional[int]											=							lr_cv[0].recv()
      process_lock.release()

      # take the higher value since you are on the right
      lowerCAmelCase__			:Optional[int]											=							max(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)
    # after all swaps are performed, send the values back to main
  result_pipe[1].send(_SCREAMING_SNAKE_CASE			)
def  __A   (_SCREAMING_SNAKE_CASE			)					->Optional[int]:





  """simple docstring"""


  lowerCAmelCase__			:str											=							[]
  lowerCAmelCase__			:Optional[Any]											=							[]
  # initialize the list of pipes where the values will be retrieved
  for _ in arr:
    result_pipe.append(Pipe()			)
  # creates the processes
  # the first and last process only have one neighbor so they are made outside
  # of the loop
  lowerCAmelCase__			:List[str]											=							Pipe()
  lowerCAmelCase__			:List[Any]											=							Pipe()
  process_array_.append(
      Process(
          target=_SCREAMING_SNAKE_CASE     ,   args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0])     ,   )			)
  lowerCAmelCase__			:Dict											=							temp_rs
  lowerCAmelCase__			:Optional[Any]											=							temp_rr

  for i in range(1     ,   len(_SCREAMING_SNAKE_CASE			) - 1			):
    lowerCAmelCase__			:Union[str, Any]											=							Pipe()
    lowerCAmelCase__			:List[str]											=							Pipe()
    process_array_.append(
        Process(
            target=_SCREAMING_SNAKE_CASE     ,   args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i])     ,   )			)
    lowerCAmelCase__			:Union[str, Any]											=							temp_rs
    lowerCAmelCase__			:Any											=							temp_rr

  process_array_.append(
      Process(
          target=_SCREAMING_SNAKE_CASE     ,   args=(
              len(_SCREAMING_SNAKE_CASE			) - 1,
              arr[len(_SCREAMING_SNAKE_CASE			) - 1],
              temp_ls,
              None,
              temp_lr,
              None,
              result_pipe[len(_SCREAMING_SNAKE_CASE			) - 1],
          )     ,   )			)

  # start the processes
  for p in process_array_:
    p.start()

  # wait for the processes to end and write their values to the list
  for p in range(0     ,   len(_SCREAMING_SNAKE_CASE			)			):
    lowerCAmelCase__			:str											=							result_pipe[p][0].recv()
    process_array_[p].join()
  return arr
def  __A   ()					->List[Any]:





  """simple docstring"""


  lowerCAmelCase__			:Union[str, Any]											=							list(range(10     ,   0     ,   -1			)			)
  print('Initial List'			)
  print(*_SCREAMING_SNAKE_CASE			)
  lowerCAmelCase__			:List[str]											=							odd_even_transposition(_SCREAMING_SNAKE_CASE			)
  print('Sorted List\n'			)
  print(*_SCREAMING_SNAKE_CASE			)


if __name__ == "__main__":
  main()
