






import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pytest

from datasets.arrow_dataset import Dataset
from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex

from .utils import require_elasticsearch, require_faiss


lowerCAmelCase_	:    Union[str, Any]            =      pytest.mark.integration





@require_faiss
class   UpperCamelCase_ (       a_  ):



  def 		UpperCamelCase_				(      self				)			->			List[Any]:



         """simple docstring"""





         UpperCAmelCase	    =			Dataset.from_dict({"""filename""": ["""my_name-train""" + """_""" + str(snake_case__				) for x in np.arange(30				).tolist()]}				)
         return dset



  def 		UpperCamelCase_				(      self				)			->			Union[str, Any]:



         """simple docstring"""





         import faiss

         UpperCAmelCase	    =			self._create_dummy_dataset()
         UpperCAmelCase	    =			dset.map(
             lambda snake_case__ ,		snake_case__				: {"vecs": i * np.ones(5 ,		dtype=np.floataa				)} ,		with_indices=snake_case__ ,		keep_in_memory=snake_case__				)
         UpperCAmelCase	    =			dset.add_faiss_index("""vecs""" ,		batch_size=1_00 ,		metric_type=faiss.METRIC_INNER_PRODUCT				)
         UpperCAmelCase    ,       UpperCAmelCase	    =			dset.get_nearest_examples("""vecs""" ,		np.ones(5 ,		dtype=np.floataa				)				)
         self.assertEqual(examples["""filename"""][0] ,		"""my_name-train_29"""				)
         dset.drop_index("""vecs"""				)



  def 		UpperCamelCase_				(      self				)			->			Optional[Any]:



         """simple docstring"""





         import faiss

         UpperCAmelCase	    =			self._create_dummy_dataset()
         dset.add_faiss_index_from_external_arrays(
             external_arrays=np.ones((30, 5)				) * np.arange(30				).reshape(-1 ,		1				) ,		index_name="""vecs""" ,		batch_size=1_00 ,		metric_type=faiss.METRIC_INNER_PRODUCT ,		)
         UpperCAmelCase    ,       UpperCAmelCase	    =			dset.get_nearest_examples("""vecs""" ,		np.ones(5 ,		dtype=np.floataa				)				)
         self.assertEqual(examples["""filename"""][0] ,		"""my_name-train_29"""				)



  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





         import faiss

         UpperCAmelCase	    =			self._create_dummy_dataset()
         dset.add_faiss_index_from_external_arrays(
             external_arrays=np.ones((30, 5)				) * np.arange(30				).reshape(-1 ,		1				) ,		index_name="""vecs""" ,		metric_type=faiss.METRIC_INNER_PRODUCT ,		)

         # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
         # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
         # see https://bugs.python.org/issue14243 and
         # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
         with tempfile.NamedTemporaryFile(delete=snake_case__				) as tmp_file:
                dset.save_faiss_index("""vecs""" ,		tmp_file.name				)
                dset.load_faiss_index("""vecs2""" ,		tmp_file.name				)
         os.unlink(tmp_file.name				)

         UpperCAmelCase    ,       UpperCAmelCase	    =			dset.get_nearest_examples("""vecs2""" ,		np.ones(5 ,		dtype=np.floataa				)				)
         self.assertEqual(examples["""filename"""][0] ,		"""my_name-train_29"""				)



  def 		UpperCamelCase_				(      self				)			->			Optional[Any]:



         """simple docstring"""





         UpperCAmelCase	    =			self._create_dummy_dataset()
         dset.add_faiss_index_from_external_arrays(
             external_arrays=np.ones((30, 5)				) * np.arange(30				).reshape(-1 ,		1				) ,		index_name="""vecs"""				)
         dset.drop_index("""vecs"""				)
         self.assertRaises(snake_case__ ,		partial(dset.get_nearest_examples ,		"""vecs2""" ,		np.ones(5 ,		dtype=np.floataa				)				)				)



  def 		UpperCamelCase_				(      self				)			->			Union[str, Any]:



         """simple docstring"""





         from elasticsearch import Elasticsearch

         UpperCAmelCase	    =			self._create_dummy_dataset()
         with patch("""elasticsearch.Elasticsearch.search"""				) as mocked_search, patch(
             """elasticsearch.client.IndicesClient.create"""				) as mocked_index_create, patch("""elasticsearch.helpers.streaming_bulk"""				) as mocked_bulk:
                UpperCAmelCase	    =			{"""acknowledged""": True}
                mocked_bulk.return_value([(True, None)] * 30				)
                UpperCAmelCase	    =			{"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 29}]}}
                UpperCAmelCase	    =			Elasticsearch()

                dset.add_elasticsearch_index("""filename""" ,		es_client=snake_case__				)
                UpperCAmelCase    ,       UpperCAmelCase	    =			dset.get_nearest_examples("""filename""" ,		"""my_name-train_29"""				)
                self.assertEqual(examples["""filename"""][0] ,		"""my_name-train_29"""				)





@require_faiss
class   UpperCamelCase_ (       a_  ):



  def 		UpperCamelCase_				(      self				)			->			Optional[int]:



         """simple docstring"""





         import faiss

         UpperCAmelCase	    =			FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT				)

         # add vectors
         index.add_vectors(np.eye(5 ,		dtype=np.floataa				)				)
         self.assertIsNotNone(index.faiss_index				)
         self.assertEqual(index.faiss_index.ntotal ,		5				)
         index.add_vectors(np.zeros((5, 5) ,		dtype=np.floataa				)				)
         self.assertEqual(index.faiss_index.ntotal ,		10				)

         # single query
         UpperCAmelCase	    =			np.zeros(5 ,		dtype=np.floataa				)
         UpperCAmelCase	    =			1
         UpperCAmelCase    ,       UpperCAmelCase	    =			index.search(snake_case__				)
         self.assertRaises(snake_case__ ,		index.search ,		query.reshape(-1 ,		1				)				)
         self.assertGreater(scores[0] ,		0				)
         self.assertEqual(indices[0] ,		1				)

         # batched queries
         UpperCAmelCase	    =			np.eye(5 ,		dtype=np.floataa				)[::-1]
         UpperCAmelCase    ,       UpperCAmelCase	    =			index.search_batch(snake_case__				)
         self.assertRaises(snake_case__ ,		index.search_batch ,		queries[0]				)
         UpperCAmelCase	    =			[scores[0] for scores in total_scores]
         UpperCAmelCase	    =			[indices[0] for indices in total_indices]
         self.assertGreater(np.min(snake_case__				) ,		0				)
         self.assertListEqual([4, 3, 2, 1, 0] ,		snake_case__				)



  def 		UpperCamelCase_				(      self				)			->			str:



         """simple docstring"""





         import faiss

         UpperCAmelCase	    =			FaissIndex(string_factory="""Flat"""				)
         index.add_vectors(np.eye(5 ,		dtype=np.floataa				)				)
         self.assertIsInstance(index.faiss_index ,		faiss.IndexFlat				)
         UpperCAmelCase	    =			FaissIndex(string_factory="""LSH"""				)
         index.add_vectors(np.eye(5 ,		dtype=np.floataa				)				)
         self.assertIsInstance(index.faiss_index ,		faiss.IndexLSH				)
         with self.assertRaises(snake_case__				):
                UpperCAmelCase	    =			FaissIndex(string_factory="""Flat""" ,		custom_index=faiss.IndexFlat(5				)				)



  def 		UpperCamelCase_				(      self				)			->			Any:



         """simple docstring"""





         import faiss

         UpperCAmelCase	    =			faiss.IndexFlat(5				)
         UpperCAmelCase	    =			FaissIndex(custom_index=snake_case__				)
         index.add_vectors(np.eye(5 ,		dtype=np.floataa				)				)
         self.assertIsInstance(index.faiss_index ,		faiss.IndexFlat				)



  def 		UpperCamelCase_				(      self				)			->			Optional[Any]:



         """simple docstring"""





         import faiss

         UpperCAmelCase	    =			FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT				)
         index.add_vectors(np.eye(5 ,		dtype=np.floataa				)				)

         # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
         # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
         # see https://bugs.python.org/issue14243 and
         # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
         with tempfile.NamedTemporaryFile(delete=snake_case__				) as tmp_file:
                index.save(tmp_file.name				)
                UpperCAmelCase	    =			FaissIndex.load(tmp_file.name				)
         os.unlink(tmp_file.name				)

         UpperCAmelCase	    =			np.zeros(5 ,		dtype=np.floataa				)
         UpperCAmelCase	    =			1
         UpperCAmelCase    ,       UpperCAmelCase	    =			index.search(snake_case__				)
         self.assertGreater(scores[0] ,		0				)
         self.assertEqual(indices[0] ,		1				)






@require_faiss
def       _lowerCAmelCase       (      lowerCAmelCase		):







       '''simple docstring'''
       import faiss

       UpperCAmelCase	    =			FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT		)
       index.add_vectors(np.eye(5	,      dtype=np.floataa		)		)

       UpperCAmelCase	    =			"""index.faiss"""
       UpperCAmelCase	    =			F'''mock://{index_name}'''
       index.save(lowerCAmelCase	,      storage_options=mockfs.storage_options		)
       UpperCAmelCase	    =			FaissIndex.load(lowerCAmelCase	,      storage_options=mockfs.storage_options		)

       UpperCAmelCase	    =			np.zeros(5	,      dtype=np.floataa		)
       UpperCAmelCase	    =			1
       UpperCAmelCase    ,       UpperCAmelCase	    =			index.search(lowerCAmelCase		)
       assert scores[0] > 0
       assert indices[0] == 1





@require_elasticsearch
class   UpperCamelCase_ (       a_  ):



  def 		UpperCamelCase_				(      self				)			->			str:



         """simple docstring"""





         from elasticsearch import Elasticsearch

         with patch("""elasticsearch.Elasticsearch.search"""				) as mocked_search, patch(
             """elasticsearch.client.IndicesClient.create"""				) as mocked_index_create, patch("""elasticsearch.helpers.streaming_bulk"""				) as mocked_bulk:
                UpperCAmelCase	    =			Elasticsearch()
                UpperCAmelCase	    =			{"""acknowledged""": True}
                UpperCAmelCase	    =			ElasticSearchIndex(es_client=snake_case__				)
                mocked_bulk.return_value([(True, None)] * 3				)
                index.add_documents(["""foo""", """bar""", """foobar"""]				)

                # single query
                UpperCAmelCase	    =			"""foo"""
                UpperCAmelCase	    =			{"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 0}]}}
                UpperCAmelCase    ,       UpperCAmelCase	    =			index.search(snake_case__				)
                self.assertEqual(scores[0] ,		1				)
                self.assertEqual(indices[0] ,		0				)

                # single query with timeout
                UpperCAmelCase	    =			"""foo"""
                UpperCAmelCase	    =			{"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 0}]}}
                UpperCAmelCase    ,       UpperCAmelCase	    =			index.search(snake_case__ ,		request_timeout=30				)
                self.assertEqual(scores[0] ,		1				)
                self.assertEqual(indices[0] ,		0				)

                # batched queries
                UpperCAmelCase	    =			["""foo""", """bar""", """foobar"""]
                UpperCAmelCase	    =			{"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 1}]}}
                UpperCAmelCase    ,       UpperCAmelCase	    =			index.search_batch(snake_case__				)
                UpperCAmelCase	    =			[scores[0] for scores in total_scores]
                UpperCAmelCase	    =			[indices[0] for indices in total_indices]
                self.assertGreater(np.min(snake_case__				) ,		0				)
                self.assertListEqual([1, 1, 1] ,		snake_case__				)

                # batched queries with timeout
                UpperCAmelCase	    =			["""foo""", """bar""", """foobar"""]
                UpperCAmelCase	    =			{"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 1}]}}
                UpperCAmelCase    ,       UpperCAmelCase	    =			index.search_batch(snake_case__ ,		request_timeout=30				)
                UpperCAmelCase	    =			[scores[0] for scores in total_scores]
                UpperCAmelCase	    =			[indices[0] for indices in total_indices]
                self.assertGreater(np.min(snake_case__				) ,		0				)
                self.assertListEqual([1, 1, 1] ,		snake_case__				)








"""simple docstring"""







from typing import List, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase_	:    str            =      logging.get_logger(__name__)

lowerCAmelCase_	:    Optional[int]            =      {
    '''huggingface/time-series-transformer-tourism-monthly''': (
        '''https://huggingface.co/huggingface/time-series-transformer-tourism-monthly/resolve/main/config.json'''
    ),
    # See all TimeSeriesTransformer models at https://huggingface.co/models?filter=time_series_transformer
}





class   UpperCamelCase_ (       a_  ):
  _A       :					int				=	'time_series_transformer'
  _A       :					List[Any]				=	{
      'hidden_size': 'd_model',
      'num_attention_heads': 'encoder_attention_heads',
      'num_hidden_layers': 'encoder_layers',
  }



  def __init__(      self ,		snake_case__ = None ,		snake_case__ = None ,		snake_case__ = "student_t" ,		snake_case__ = "nll" ,		snake_case__ = 1 ,		snake_case__ = [1, 2, 3, 4, 5, 6, 7] ,		snake_case__ = "mean" ,		snake_case__ = 0 ,		snake_case__ = 0 ,		snake_case__ = 0 ,		snake_case__ = 0 ,		snake_case__ = None ,		snake_case__ = None ,		snake_case__ = 32 ,		snake_case__ = 32 ,		snake_case__ = 2 ,		snake_case__ = 2 ,		snake_case__ = 2 ,		snake_case__ = 2 ,		snake_case__ = True ,		snake_case__ = "gelu" ,		snake_case__ = 64 ,		snake_case__ = 0.1 ,		snake_case__ = 0.1 ,		snake_case__ = 0.1 ,		snake_case__ = 0.1 ,		snake_case__ = 0.1 ,		snake_case__ = 1_00 ,		snake_case__ = 0.02 ,		snake_case__=True ,		**snake_case__ ,		)			->			Union[str, Any]:



         """simple docstring"""





         UpperCAmelCase	    =			prediction_length
         UpperCAmelCase	    =			context_length or prediction_length
         UpperCAmelCase	    =			distribution_output
         UpperCAmelCase	    =			loss
         UpperCAmelCase	    =			input_size
         UpperCAmelCase	    =			num_time_features
         UpperCAmelCase	    =			lags_sequence
         UpperCAmelCase	    =			scaling
         UpperCAmelCase	    =			num_dynamic_real_features
         UpperCAmelCase	    =			num_static_real_features
         UpperCAmelCase	    =			num_static_categorical_features
         if cardinality and num_static_categorical_features > 0:
                if len(snake_case__				) != num_static_categorical_features:
                       raise ValueError(
                           """The cardinality should be a list of the same length as `num_static_categorical_features`"""				)
                UpperCAmelCase	    =			cardinality
         else:
                UpperCAmelCase	    =			[0]
         if embedding_dimension and num_static_categorical_features > 0:
                if len(snake_case__				) != num_static_categorical_features:
                       raise ValueError(
                           """The embedding dimension should be a list of the same length as `num_static_categorical_features`"""				)
                UpperCAmelCase	    =			embedding_dimension
         else:
                UpperCAmelCase	    =			[min(50 ,		(cat + 1) // 2				) for cat in self.cardinality]
         UpperCAmelCase	    =			num_parallel_samples

         # Transformer architecture configuration
         UpperCAmelCase	    =			input_size * len(snake_case__				) + self._number_of_features
         UpperCAmelCase	    =			d_model
         UpperCAmelCase	    =			encoder_attention_heads
         UpperCAmelCase	    =			decoder_attention_heads
         UpperCAmelCase	    =			encoder_ffn_dim
         UpperCAmelCase	    =			decoder_ffn_dim
         UpperCAmelCase	    =			encoder_layers
         UpperCAmelCase	    =			decoder_layers

         UpperCAmelCase	    =			dropout
         UpperCAmelCase	    =			attention_dropout
         UpperCAmelCase	    =			activation_dropout
         UpperCAmelCase	    =			encoder_layerdrop
         UpperCAmelCase	    =			decoder_layerdrop

         UpperCAmelCase	    =			activation_function
         UpperCAmelCase	    =			init_std

         UpperCAmelCase	    =			use_cache

         super().__init__(is_encoder_decoder=snake_case__ ,		**snake_case__				)



  @property
  def 		UpperCamelCase_				(      self				)			->			int:



         """simple docstring"""





         return (
             sum(self.embedding_dimension				)
             + self.num_dynamic_real_features
             + self.num_time_features
             + self.num_static_real_features
             + self.input_size * 2  # the log1p(abs(loc)) and log(scale) features
         )
