






"""simple docstring"""







import io
import itertools
import json
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa
import pyarrow.json as paj

import datasets
from datasets.table import table_cast
from datasets.utils.file_utils import readline


_lowerCAmelCase            =	datasets.utils.logging.get_logger(__name__)


@dataclass
class      UpperCamelCase		(datasets.BuilderConfig     ):
						_SCREAMING_SNAKE_CASE  : List[str]												=		None
						_SCREAMING_SNAKE_CASE  : List[Any]												=		"""utf-8"""
						_SCREAMING_SNAKE_CASE  : Optional[int]												=		None
						_SCREAMING_SNAKE_CASE  : str												=		None
						_SCREAMING_SNAKE_CASE  : Dict												=		True  # deprecated
						_SCREAMING_SNAKE_CASE  : List[str]												=		None  # deprecated
						_SCREAMING_SNAKE_CASE  : Optional[int]												=		10 << 20  # 10MB
						_SCREAMING_SNAKE_CASE  : List[str]												=		None


class      UpperCamelCase		(datasets.ArrowBasedBuilder     ):
						_SCREAMING_SNAKE_CASE  : List[Any]												=		JsonConfig






						def      __snake_case      (		self  :Optional[Any]				)      ->List[str]:
										if self.config.block_size is not None:
														logger.warning("""The JSON loader parameter `block_size` is deprecated. Please use `chunksize` instead"""				)
														lowercase    :      List[Any]       = self.config.block_size
										if self.config.use_threads is not True:
														logger.warning(
														    """The JSON loader parameter `use_threads` is deprecated and doesn\'t have any effect anymore."""				)
										if self.config.newlines_in_values is not None:
														raise ValueError("""The JSON loader parameter `newlines_in_values` is no longer supported"""				)
										return datasets.DatasetInfo(features=self.config.features				)






						def      __snake_case      (		self  :Union[str, Any]			, __magic_name__  :int				)      ->int:
										if not self.config.data_files:
														raise ValueError(f"""At least one data file must be specified, but got data_files={self.config.data_files}"""				)
										lowercase    :      int       = dl_manager.download_and_extract(self.config.data_files				)
										if isinstance(lowercase_			, (str, list, tuple)				):
														lowercase    :      Any       = data_files
														if isinstance(lowercase_			, lowercase_				):
																		lowercase    :      Union[str, Any]       = [files]
														lowercase    :      int       = [dl_manager.iter_files(lowercase_				) for file in files]
														return [datasets.SplitGenerator(name=datasets.Split.TRAIN			, gen_kwargs={"""files""": files}				)]
										lowercase    :      int       = []
										for split_name, files in data_files.items():
														if isinstance(lowercase_			, lowercase_				):
																		lowercase    :      int       = [files]
														lowercase    :      str       = [dl_manager.iter_files(lowercase_				) for file in files]
														splits.append(datasets.SplitGenerator(name=lowercase_			, gen_kwargs={"""files""": files}				)				)
										return splits






						def      __snake_case      (		self  :Tuple			, __magic_name__  :Union[str, Any]				)      ->pa.Table:
										if self.config.features is not None:
														# adding missing columns
														for column_name in set(self.config.features				) - set(pa_table.column_names				):
																		lowercase    :      Any       = self.config.features.arrow_schema.field(lowercase_				).type
																		lowercase    :      Optional[Any]       = pa_table.append_column(lowercase_			, pa.array([None] * len(lowercase_				)			, type=lowercase_				)				)
														# more expensive cast to support nested structures with keys in a different order
														# allows str <-> int/float or str to Audio for example
														lowercase    :      Tuple       = table_cast(lowercase_			, self.config.features.arrow_schema				)
										return pa_table






						def      __snake_case      (		self  :Optional[Any]			, __magic_name__  :int				)      ->Optional[int]:
										for file_idx, file in enumerate(itertools.chain.from_iterable(lowercase_				)				):
														# If the file is one json object and if we need to look at the list of items in one specific field
														if self.config.field is not None:
																		with open(lowercase_			, encoding=self.config.encoding			, errors=self.config.encoding_errors				) as f:
																						lowercase    :      Dict       = json.load(lowercase_				)

																		# We keep only the field we are interested in
																		lowercase    :      Any       = dataset[self.config.field]

																		# We accept two format: a list of dicts or a dict of lists
																		if isinstance(lowercase_			, (list, tuple)				):
																						lowercase    :      Any       = set().union(*[row.keys() for row in dataset]				)
																						lowercase    :      int       = {col: [row.get(lowercase_				) for row in dataset] for col in keys}
																		else:
																						lowercase    :      Union[str, Any]       = dataset
																		lowercase    :      Dict       = pa.Table.from_pydict(lowercase_				)
																		yield file_idx, self._cast_table(lowercase_				)

														# If the file has one json object per line
														else:
																		with open(lowercase_			, """rb"""				) as f:
																						lowercase    :      Optional[Any]       = 0
																						# Use block_size equal to the chunk size divided by 32 to leverage multithreading
																						# Set a default minimum value of 16kB if the chunk size is really small
																						lowercase    :      Tuple       = max(self.config.chunksize // 32			, 16 << 10				)
																						lowercase    :      str       = (
																						    self.config.encoding_errors if self.config.encoding_errors is not None else """strict"""
																						)
																						while True:
																										lowercase    :      Dict       = f.read(self.config.chunksize				)
																										if not batch:
																														break
																										# Finish current line
																										try:
																														batch += f.readline()
																										except (AttributeError, io.UnsupportedOperation):
																														batch += readline(lowercase_				)
																										# PyArrow only accepts utf-8 encoded bytes
																										if self.config.encoding != "utf-8":
																														lowercase    :      Optional[int]       = batch.decode(self.config.encoding			, errors=lowercase_				).encode("""utf-8"""				)
																										try:
																														while True:
																																		try:
																																						lowercase    :      Tuple       = paj.read_json(
																																						    io.BytesIO(lowercase_				)			, read_options=paj.ReadOptions(block_size=lowercase_				)				)
																																						break
																																		except (pa.ArrowInvalid, pa.ArrowNotImplementedError) as e:
																																						if (
																																						    isinstance(lowercase_			, pa.ArrowInvalid				)
																																						    and "straddling" not in str(lowercase_				)
																																						    or block_size > len(lowercase_				)
																																						):
																																										raise
																																						else:
																																										# Increase the block size in case it was too small.
																																										# The block size will be reset for the next file.
																																										logger.debug(
																																										    f"""Batch of {len(lowercase_				)} bytes couldn't be parsed with block_size={block_size}. Retrying with block_size={block_size * 2}."""				)
																																										block_size *= 2
																										except pa.ArrowInvalid as e:
																														try:
																																		with open(
																																		    lowercase_			, encoding=self.config.encoding			, errors=self.config.encoding_errors				) as f:
																																						lowercase    :      str       = json.load(lowercase_				)
																														except json.JSONDecodeError:
																																		logger.error(f"""Failed to read file '{file}' with error {type(lowercase_				)}: {e}"""				)
																																		raise e
																														# If possible, parse the file as a list of json objects and exit the loop
																														if isinstance(lowercase_			, lowercase_				):  # list is the only sequence type supported in JSON
																																		try:
																																						lowercase    :      List[Any]       = set().union(*[row.keys() for row in dataset]				)
																																						lowercase    :      int       = {col: [row.get(lowercase_				) for row in dataset] for col in keys}
																																						lowercase    :      Tuple       = pa.Table.from_pydict(lowercase_				)
																																		except (pa.ArrowInvalid, AttributeError) as e:
																																						logger.error(f"""Failed to read file '{file}' with error {type(lowercase_				)}: {e}"""				)
																																						raise ValueError(f"""Not able to read records in the JSON file at {file}."""				) from None
																																		yield file_idx, self._cast_table(lowercase_				)
																																		break
																														else:
																																		logger.error(f"""Failed to read file '{file}' with error {type(lowercase_				)}: {e}"""				)
																																		raise ValueError(
																																		    f"""Not able to read records in the JSON file at {file}. """
																																		    f"""You should probably indicate the field of the JSON file containing your records. """
																																		    f"""This JSON file contain the following fields: {str(list(dataset.keys()				)				)}. """
																																		    f"""Select the correct one and provide it as `field='XXX'` to the dataset loading method. """				) from None
                        # Uncomment for debugging (will print the Arrow table size and elements)
                        # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                        # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
																										yield (file_idx, batch_idx), self._cast_table(lowercase_				)
																										batch_idx += 1




from typing import List, Optional

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


_lowerCAmelCase:						List[Any]   				=       logging.get_logger(__name__)

_lowerCAmelCase:						Any   				=       {
    'huggingface/autoformer-tourism-monthly': 'https://huggingface.co/huggingface/autoformer-tourism-monthly/resolve/main/config.json',
}




class       lowercase_					(lowercase__   ):
				snake_case	    ='autoformer'
				snake_case	    ={
				    'hidden_size': 'd_model',
				    'num_attention_heads': 'encoder_attention_heads',
				    'num_hidden_layers': 'encoder_layers',
				}





				def __init__(				self       ,  lowercase_ = None       ,  lowercase_ = None       ,  lowercase_ = "student_t"       ,  lowercase_ = "nll"       ,  lowercase_ = 1       ,  lowercase_ = [1, 2, 3, 4, 5, 6, 7]       ,  lowercase_ = True       ,  lowercase_ = 0       ,  lowercase_ = 0       ,  lowercase_ = 0       ,  lowercase_ = 0       ,  lowercase_ = None       ,  lowercase_ = None       ,  lowercase_ = 64       ,  lowercase_ = 2       ,  lowercase_ = 2       ,  lowercase_ = 2       ,  lowercase_ = 2       ,  lowercase_ = 32       ,  lowercase_ = 32       ,  lowercase_ = "gelu"       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 100       ,  lowercase_ = 0.02       ,  lowercase_ = True       ,  lowercase_=True       ,  lowercase_ = 10       ,  lowercase_ = 25       ,  lowercase_ = 3       ,  **lowercase_       ,  )  -> Union[str, Any]:
											# time series specific configuration
											a__      =prediction_length
											a__      =context_length if context_length is not None else prediction_length
											a__      =distribution_output
											a__      =loss
											a__      =input_size
											a__      =num_time_features
											a__      =lags_sequence
											a__      =scaling
											a__      =num_dynamic_real_features
											a__      =num_static_real_features
											a__      =num_static_categorical_features
											if cardinality is not None and num_static_categorical_features > 0:
																		if len(lowercase_) != num_static_categorical_features:
																									raise ValueError(
																									    'The cardinality should be a list of the same length as `num_static_categorical_features`')
																		a__      =cardinality
											else:
																		a__      =[0]
											if embedding_dimension is not None and num_static_categorical_features > 0:
																		if len(lowercase_) != num_static_categorical_features:
																									raise ValueError(
																									    'The embedding dimension should be a list of the same length as `num_static_categorical_features`')
																		a__      =embedding_dimension
											else:
																		a__      =[min(50       ,  (cat + 1) // 2) for cat in self.cardinality]
											a__      =num_parallel_samples

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

											a__      =dropout
											a__      =attention_dropout
											a__      =activation_dropout
											a__      =encoder_layerdrop
											a__      =decoder_layerdrop

											a__      =activation_function
											a__      =init_std

											a__      =use_cache

											# Autoformer
											a__      =label_length
											a__      =moving_average
											a__      =autocorrelation_factor

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





				@property
				def 						__UpperCamelCase    (				self)  -> int:
											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
											)

