


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


SCREAMING_SNAKE_CASE			: Tuple				   =					get_logger(__name__)


SCREAMING_SNAKE_CASE			: List[Any]				   =					Path(__file__).parent / "model_card_template.md"
SCREAMING_SNAKE_CASE			: Union[str, Any]				   =					uuida().hex
SCREAMING_SNAKE_CASE			: str				   =					os.getenv("HF_HUB_OFFLINE", "").upper() in ENV_VARS_TRUE_VALUES
SCREAMING_SNAKE_CASE			: List[Any]				   =					os.getenv("DISABLE_TELEMETRY", "").upper() in ENV_VARS_TRUE_VALUES
SCREAMING_SNAKE_CASE			: int				   =					HUGGINGFACE_CO_RESOLVE_ENDPOINT + "/api/telemetry/"



def 							UpperCamelCase_( lowerCamelCase_ = None					)       ->		List[Any]:
    _lowercase			:				List[Any] 						=						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(lowerCAmelCase__				,					lowerCAmelCase__					):
        ua += "; " + "; ".join(F'''{k}/{v}''' for k, v in user_agent.items()					)
    elif isinstance(lowerCAmelCase__				,					lowerCAmelCase__					):
        ua += "; " + user_agent
    return ua



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_ = None				,					lowerCamelCase_ = None					)       ->		str:
    if token is None:
        _lowercase			:				Union[str, Any] 						=						HfFolder.get_token()
    if organization is None:
        _lowercase			:				Dict 						=						whoami(lowerCAmelCase__					)['name']
        return F'''{username}/{model_id}'''
    else:
        return F'''{organization}/{model_id}'''



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_					)       ->		Any:
    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(lowerCAmelCase__				,					'local_rank'					) and args.local_rank not in [-1, 0]:
        return

    _lowercase			:				Optional[int] 						=						args.hub_token if hasattr(lowerCAmelCase__				,					'hub_token'					) else None
    _lowercase			:				int 						=						get_full_repo_name(lowerCAmelCase__				,					token=lowerCAmelCase__					)

    _lowercase			:				List[str] 						=						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=lowerCAmelCase__				,					model_name=lowerCAmelCase__				,					repo_name=lowerCAmelCase__				,					dataset_name=args.dataset_name if hasattr(lowerCAmelCase__				,					'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(lowerCAmelCase__				,					'gradient_accumulation_steps'					) else None
        )				,					adam_betaa=args.adam_betaa if hasattr(lowerCAmelCase__				,					'adam_beta1'					) else None				,					adam_betaa=args.adam_betaa if hasattr(lowerCAmelCase__				,					'adam_beta2'					) else None				,					adam_weight_decay=args.adam_weight_decay if hasattr(lowerCAmelCase__				,					'adam_weight_decay'					) else None				,					adam_epsilon=args.adam_epsilon if hasattr(lowerCAmelCase__				,					'adam_epsilon'					) else None				,					lr_scheduler=args.lr_scheduler if hasattr(lowerCAmelCase__				,					'lr_scheduler'					) else None				,					lr_warmup_steps=args.lr_warmup_steps if hasattr(lowerCAmelCase__				,					'lr_warmup_steps'					) else None				,					ema_inv_gamma=args.ema_inv_gamma if hasattr(lowerCAmelCase__				,					'ema_inv_gamma'					) else None				,					ema_power=args.ema_power if hasattr(lowerCAmelCase__				,					'ema_power'					) else None				,					ema_max_decay=args.ema_max_decay if hasattr(lowerCAmelCase__				,					'ema_max_decay'					) else None				,					mixed_precision=args.mixed_precision				,					)

    _lowercase			:				List[Any] 						=						os.path.join(args.output_dir				,					'README.md'					)
    model_card.save(lowerCAmelCase__					)



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_ = None					)       ->		Any:
    if resolved_file is None or commit_hash is not None:
        return commit_hash
    _lowercase			:				int 						=						str(Path(lowerCAmelCase__					).as_posix()					)
    _lowercase			:				Any 						=						re.search(R'snapshots/([^/]+)/'				,					lowerCAmelCase__					)
    if search is None:
        return None
    _lowercase			:				Any 						=						search.groups()[0]
    return commit_hash if REGEX_COMMIT_HASH.match(lowerCAmelCase__					) 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.
SCREAMING_SNAKE_CASE			: List[str]				   =					os.path.expanduser(
    os.getenv("HF_HOME", os.path.join(os.getenv("XDG_CACHE_HOME", "~/.cache"), "huggingface"))
)
SCREAMING_SNAKE_CASE			: Optional[Any]				   =					os.path.join(hf_cache_home, "diffusers")



def 							UpperCamelCase_( lowerCamelCase_ = None				,					lowerCamelCase_ = None					)       ->		Any:
    if new_cache_dir is None:
        _lowercase			:				List[Any] 						=						DIFFUSERS_CACHE
    if old_cache_dir is None:
        _lowercase			:				Any 						=						old_diffusers_cache

    _lowercase			:				Tuple 						=						Path(lowerCAmelCase__					).expanduser()
    _lowercase			:				Union[str, Any] 						=						Path(lowerCAmelCase__					).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			:				int 						=						new_cache_dir / old_blob_path.relative_to(lowerCAmelCase__					)
            new_blob_path.parent.mkdir(parents=lowerCAmelCase__				,					exist_ok=lowerCAmelCase__					)
            os.replace(lowerCAmelCase__				,					lowerCAmelCase__					)
            try:
                os.symlink(lowerCAmelCase__				,					lowerCAmelCase__					)
            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).


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

if cache_version < 1:
 SCREAMING_SNAKE_CASE			: Dict				   =					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:
   SCREAMING_SNAKE_CASE			: Optional[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 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_ = None					)       ->		List[Any]:
    if variant is not None:
        _lowercase			:				int 						=						weights_name.split('.'					)
        _lowercase			:				Optional[Any] 						=						splits[:-1] + [variant] + splits[-1:]
        _lowercase			:				Union[str, Any] 						=						'.'.join(lowerCAmelCase__					)

    return weights_name



def 							UpperCamelCase_( lowerCamelCase_				,					*,
    lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_=None				,					)       ->		List[str]:
    _lowercase			:				Tuple 						=						str(lowerCAmelCase__					)
    if os.path.isfile(lowerCAmelCase__					):
        return pretrained_model_name_or_path
    elif os.path.isdir(lowerCAmelCase__					):
        if os.path.isfile(os.path.join(lowerCAmelCase__				,					lowerCAmelCase__					)					):
            # Load from a PyTorch checkpoint
            _lowercase			:				List[Any] 						=						os.path.join(lowerCAmelCase__				,					lowerCAmelCase__					)
            return model_file
        elif subfolder is not None and os.path.isfile(
            os.path.join(lowerCAmelCase__				,					lowerCAmelCase__				,					lowerCAmelCase__					)					):
            _lowercase			:				Union[str, Any] 						=						os.path.join(lowerCAmelCase__				,					lowerCAmelCase__				,					lowerCAmelCase__					)
            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(lowerCAmelCase__					).base_version					) >= version.parse('0.20.0'					)
        ):
            try:
                _lowercase			:				Union[str, Any] 						=						hf_hub_download(
                    lowerCAmelCase__				,					filename=_add_variant(lowerCAmelCase__				,					lowerCAmelCase__					)				,					cache_dir=lowerCAmelCase__				,					force_download=lowerCAmelCase__				,					proxies=lowerCAmelCase__				,					resume_download=lowerCAmelCase__				,					local_files_only=lowerCAmelCase__				,					use_auth_token=lowerCAmelCase__				,					user_agent=lowerCAmelCase__				,					subfolder=lowerCAmelCase__				,					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.'''				,					lowerCAmelCase__				,					)
                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(lowerCAmelCase__				,					lowerCAmelCase__					)} 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(lowerCAmelCase__				,					lowerCAmelCase__					)}\' so that the correct variant file can be added.'''				,					lowerCAmelCase__				,					)
        try:
            # 2. Load model file as usual
            _lowercase			:				Optional[int] 						=						hf_hub_download(
                lowerCAmelCase__				,					filename=lowerCAmelCase__				,					cache_dir=lowerCAmelCase__				,					force_download=lowerCAmelCase__				,					proxies=lowerCAmelCase__				,					resume_download=lowerCAmelCase__				,					local_files_only=lowerCAmelCase__				,					use_auth_token=lowerCAmelCase__				,					user_agent=lowerCAmelCase__				,					subfolder=lowerCAmelCase__				,					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"""


import unittest

import numpy as np

from transformers import is_flax_available
from transformers.testing_utils import require_flax

from ..test_modeling_flax_common import ids_tensor


if is_flax_available():
						import jax
						import jax.numpy as jnp

						from transformers.generation import (
						    FlaxForcedBOSTokenLogitsProcessor,
						    FlaxForcedEOSTokenLogitsProcessor,
						    FlaxLogitsProcessorList,
						    FlaxMinLengthLogitsProcessor,
						    FlaxTemperatureLogitsWarper,
						    FlaxTopKLogitsWarper,
						    FlaxTopPLogitsWarper,
						)




@require_flax
class  __lowerCamelCase  ( unittest.TestCase			):




				def        UpperCAmelCase__						(				self							,						UpperCAmelCase							,						UpperCAmelCase   ):
							lowerCamelCase_					=  jnp.ones((batch_size, length)   ) / length
							return scores




				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  None
							lowerCamelCase_					=  20

							lowerCamelCase_					=  self._get_uniform_logits(batch_size=2							,						length=UpperCAmelCase   )

							# tweak scores to not be uniform anymore
							lowerCamelCase_					=  scores.at[1, 5].set((1 / length) + 0.1   )  # peak, 1st batch
							lowerCamelCase_					=  scores.at[1, 10].set((1 / length) - 0.4   )  # valley, 1st batch

							# compute softmax
							lowerCamelCase_					=  jax.nn.softmax(UpperCAmelCase							,						axis=-1   )

							lowerCamelCase_					=  FlaxTemperatureLogitsWarper(temperature=0.5   )
							lowerCamelCase_					=  FlaxTemperatureLogitsWarper(temperature=1.3   )

							lowerCamelCase_					=  jax.nn.softmax(temp_dist_warper_sharper(UpperCAmelCase							,						scores.copy()							,						cur_len=UpperCAmelCase   )							,						axis=-1   )
							lowerCamelCase_					=  jax.nn.softmax(temp_dist_warper_smoother(UpperCAmelCase							,						scores.copy()							,						cur_len=UpperCAmelCase   )							,						axis=-1   )

							# uniform distribution stays uniform
							self.assertTrue(jnp.allclose(probs[0, :]							,						warped_prob_sharp[0, :]							,						atol=1e-3   )   )
							self.assertTrue(jnp.allclose(probs[0, :]							,						warped_prob_smooth[0, :]							,						atol=1e-3   )   )

							# sharp peaks get higher, valleys get lower
							self.assertLess(probs[1, :].max()							,						warped_prob_sharp[1, :].max()   )
							self.assertGreater(probs[1, :].min()							,						warped_prob_sharp[1, :].min()   )

							# smooth peaks get lower, valleys get higher
							self.assertGreater(probs[1, :].max()							,						warped_prob_smooth[1, :].max()   )
							self.assertLess(probs[1, :].min()							,						warped_prob_smooth[1, :].min()   )




				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  None
							lowerCamelCase_					=  10
							lowerCamelCase_					=  2

							# create ramp distribution
							lowerCamelCase_					=  np.broadcast_to(np.arange(UpperCAmelCase   )[None, :]							,						(batch_size, vocab_size)   ).copy()
							lowerCamelCase_					=  ramp_logits[1:, : vocab_size // 2] + vocab_size

							lowerCamelCase_					=  FlaxTopKLogitsWarper(3   )

							lowerCamelCase_					=  top_k_warp(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )

							# check that correct tokens are filtered
							self.assertListEqual(jnp.isinf(scores[0]   ).tolist()							,						7 * [True] + 3 * [False]   )
							self.assertListEqual(jnp.isinf(scores[1]   ).tolist()							,						2 * [True] + 3 * [False] + 5 * [True]   )

							# check special case
							lowerCamelCase_					=  5
							lowerCamelCase_					=  FlaxTopKLogitsWarper(top_k=1							,						filter_value=0.0							,						min_tokens_to_keep=3   )

							lowerCamelCase_					=  np.broadcast_to(np.arange(UpperCAmelCase   )[None, :]							,						(batch_size, length)   ).copy()
							lowerCamelCase_					=  top_k_warp_safety_check(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )

							# min_tokens overwrites k: 3 tokens are kept => 2 tokens are nullified
							self.assertListEqual((scores == 0.0).sum(axis=-1   ).tolist()							,						[2, 2]   )




				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  None
							lowerCamelCase_					=  10
							lowerCamelCase_					=  2

							# create distribution and take log (inverse to Softmax as taken in TopPLogitsWarper)
							lowerCamelCase_					=  np.log(np.array([[0.3, 0.1, 0.1, 0.5], [0.1_5, 0.3, 0.3, 0.2_5]]   )   )

							lowerCamelCase_					=  FlaxTopPLogitsWarper(0.8   )
							lowerCamelCase_					=  np.exp(top_p_warp(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )   )

							# dist should be filtered to keep min num values so that sum is >= top_p
							# exp (-inf) => 0
							lowerCamelCase_					=  np.array([[0.3, 0.0, 0.0, 0.5], [0.0, 0.3, 0.3, 0.2_5]]   )
							self.assertTrue(np.allclose(UpperCAmelCase							,						UpperCAmelCase							,						atol=1e-3   )   )

							# check edge cases with negative and extreme logits
							lowerCamelCase_					=  np.broadcast_to(np.arange(UpperCAmelCase   )[None, :]							,						(batch_size, vocab_size)   ).copy() - (
							    vocab_size // 2
							)

							# make ramp_logits more extreme
							lowerCamelCase_					=  ramp_logits[1] * 1_0_0.0

							# make sure at least 2 tokens are kept
							lowerCamelCase_					=  FlaxTopPLogitsWarper(0.9							,						min_tokens_to_keep=2							,						filter_value=0.0   )
							lowerCamelCase_					=  top_p_warp(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )

							# first batch should keep three tokens, second batch would keep only 1, but due to `min_tokens_to_keep=2` keeps 2.
							self.assertListEqual((filtered_dist != 0.0).sum(axis=-1   ).tolist()							,						[3, 2]   )




				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  20
							lowerCamelCase_					=  4
							lowerCamelCase_					=  0

							lowerCamelCase_					=  FlaxMinLengthLogitsProcessor(min_length=10							,						eos_token_id=UpperCAmelCase   )

							# check that min length is applied at length 5
							lowerCamelCase_					=  ids_tensor((batch_size, 20)							,						vocab_size=20   )
							lowerCamelCase_					=  5
							lowerCamelCase_					=  self._get_uniform_logits(UpperCAmelCase							,						UpperCAmelCase   )
							lowerCamelCase_					=  min_dist_processor(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							self.assertListEqual(scores_before_min_length[:, eos_token_id].tolist()							,						4 * [-float('''inf'''   )]   )

							# check that min length is not applied anymore at length 15
							lowerCamelCase_					=  self._get_uniform_logits(UpperCAmelCase							,						UpperCAmelCase   )
							lowerCamelCase_					=  15
							lowerCamelCase_					=  min_dist_processor(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							self.assertFalse(jnp.isinf(UpperCAmelCase   ).any()   )




				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  20
							lowerCamelCase_					=  4
							lowerCamelCase_					=  0

							lowerCamelCase_					=  FlaxForcedBOSTokenLogitsProcessor(bos_token_id=UpperCAmelCase   )

							# check that all scores are -inf except the bos_token_id score
							lowerCamelCase_					=  ids_tensor((batch_size, 1)							,						vocab_size=20   )
							lowerCamelCase_					=  1
							lowerCamelCase_					=  self._get_uniform_logits(UpperCAmelCase							,						UpperCAmelCase   )
							lowerCamelCase_					=  logits_processor(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							self.assertTrue(jnp.isneginf(scores[:, bos_token_id + 1 :]   ).all()   )
							self.assertListEqual(scores[:, bos_token_id].tolist()							,						4 * [0]   )  # score for bos_token_id shold be zero

							# check that bos_token_id is not forced if current length is greater than 1
							lowerCamelCase_					=  3
							lowerCamelCase_					=  self._get_uniform_logits(UpperCAmelCase							,						UpperCAmelCase   )
							lowerCamelCase_					=  logits_processor(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							self.assertFalse(jnp.isinf(UpperCAmelCase   ).any()   )




				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  20
							lowerCamelCase_					=  4
							lowerCamelCase_					=  0
							lowerCamelCase_					=  5

							lowerCamelCase_					=  FlaxForcedEOSTokenLogitsProcessor(max_length=UpperCAmelCase							,						eos_token_id=UpperCAmelCase   )

							# check that all scores are -inf except the eos_token_id when max_length is reached
							lowerCamelCase_					=  ids_tensor((batch_size, 4)							,						vocab_size=20   )
							lowerCamelCase_					=  4
							lowerCamelCase_					=  self._get_uniform_logits(UpperCAmelCase							,						UpperCAmelCase   )
							lowerCamelCase_					=  logits_processor(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							self.assertTrue(jnp.isneginf(scores[:, eos_token_id + 1 :]   ).all()   )
							self.assertListEqual(scores[:, eos_token_id].tolist()							,						4 * [0]   )  # score for eos_token_id should be zero

							# check that eos_token_id is not forced if max_length is not reached
							lowerCamelCase_					=  3
							lowerCamelCase_					=  self._get_uniform_logits(UpperCAmelCase							,						UpperCAmelCase   )
							lowerCamelCase_					=  logits_processor(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							self.assertFalse(jnp.isinf(UpperCAmelCase   ).any()   )




				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  4
							lowerCamelCase_					=  10
							lowerCamelCase_					=  15
							lowerCamelCase_					=  2
							lowerCamelCase_					=  1
							lowerCamelCase_					=  15

							# dummy input_ids and scores
							lowerCamelCase_					=  ids_tensor((batch_size, sequence_length)							,						UpperCAmelCase   )
							lowerCamelCase_					=  input_ids.copy()

							lowerCamelCase_					=  self._get_uniform_logits(UpperCAmelCase							,						UpperCAmelCase   )
							lowerCamelCase_					=  scores.copy()

							# instantiate all dist processors
							lowerCamelCase_					=  FlaxTemperatureLogitsWarper(temperature=0.5   )
							lowerCamelCase_					=  FlaxTopKLogitsWarper(3   )
							lowerCamelCase_					=  FlaxTopPLogitsWarper(0.8   )

							# instantiate all logits processors
							lowerCamelCase_					=  FlaxMinLengthLogitsProcessor(min_length=10							,						eos_token_id=UpperCAmelCase   )
							lowerCamelCase_					=  FlaxForcedBOSTokenLogitsProcessor(bos_token_id=UpperCAmelCase   )
							lowerCamelCase_					=  FlaxForcedEOSTokenLogitsProcessor(max_length=UpperCAmelCase							,						eos_token_id=UpperCAmelCase   )

							lowerCamelCase_					=  10

							# no processor list
							lowerCamelCase_					=  temp_dist_warp(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							lowerCamelCase_					=  top_k_warp(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							lowerCamelCase_					=  top_p_warp(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							lowerCamelCase_					=  min_dist_proc(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							lowerCamelCase_					=  bos_dist_proc(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
							lowerCamelCase_					=  eos_dist_proc(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )

							# with processor list
							lowerCamelCase_					=  FlaxLogitsProcessorList(
							    [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]   )
							lowerCamelCase_					=  processor(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )

							# scores should be equal
							self.assertTrue(jnp.allclose(UpperCAmelCase							,						UpperCAmelCase							,						atol=1e-3   )   )

							# input_ids should never be changed
							self.assertListEqual(input_ids.tolist()							,						input_ids_comp.tolist()   )





				def        UpperCAmelCase__						(				self   ):
							lowerCamelCase_					=  4
							lowerCamelCase_					=  10
							lowerCamelCase_					=  15
							lowerCamelCase_					=  2
							lowerCamelCase_					=  1
							lowerCamelCase_					=  15

							# dummy input_ids and scores
							lowerCamelCase_					=  ids_tensor((batch_size, sequence_length)							,						UpperCAmelCase   )
							lowerCamelCase_					=  input_ids.copy()

							lowerCamelCase_					=  self._get_uniform_logits(UpperCAmelCase							,						UpperCAmelCase   )
							lowerCamelCase_					=  scores.copy()

							# instantiate all dist processors
							lowerCamelCase_					=  FlaxTemperatureLogitsWarper(temperature=0.5   )
							lowerCamelCase_					=  FlaxTopKLogitsWarper(3   )
							lowerCamelCase_					=  FlaxTopPLogitsWarper(0.8   )

							# instantiate all logits processors
							lowerCamelCase_					=  FlaxMinLengthLogitsProcessor(min_length=10							,						eos_token_id=UpperCAmelCase   )
							lowerCamelCase_					=  FlaxForcedBOSTokenLogitsProcessor(bos_token_id=UpperCAmelCase   )
							lowerCamelCase_					=  FlaxForcedEOSTokenLogitsProcessor(max_length=UpperCAmelCase							,						eos_token_id=UpperCAmelCase   )

							lowerCamelCase_					=  10

							# no processor list
							def run_no_processor_list(UpperCAmelCase							,						UpperCAmelCase							,						UpperCAmelCase   ):
										lowerCamelCase_					=  temp_dist_warp(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
										lowerCamelCase_					=  top_k_warp(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
										lowerCamelCase_					=  top_p_warp(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
										lowerCamelCase_					=  min_dist_proc(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
										lowerCamelCase_					=  bos_dist_proc(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
										lowerCamelCase_					=  eos_dist_proc(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
										return scores

							# with processor list
							def run_processor_list(UpperCAmelCase							,						UpperCAmelCase							,						UpperCAmelCase   ):
										lowerCamelCase_					=  FlaxLogitsProcessorList(
										    [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]   )
										lowerCamelCase_					=  processor(UpperCAmelCase							,						UpperCAmelCase							,						cur_len=UpperCAmelCase   )
										return scores

							lowerCamelCase_					=  jax.jit(UpperCAmelCase   )
							lowerCamelCase_					=  jax.jit(UpperCAmelCase   )

							lowerCamelCase_					=  jitted_run_no_processor_list(UpperCAmelCase							,						UpperCAmelCase							,						UpperCAmelCase   )
							lowerCamelCase_					=  jitted_run_processor_list(UpperCAmelCase							,						UpperCAmelCase							,						UpperCAmelCase   )

							# scores should be equal
							self.assertTrue(jnp.allclose(UpperCAmelCase							,						UpperCAmelCase							,						atol=1e-3   )   )

							# input_ids should never be changed
							self.assertListEqual(input_ids.tolist()							,						input_ids_comp.tolist()   )



