


import collections
import types

import numpy as np

from ..utils import (
    add_end_docstrings,
    is_tensorflow_probability_available,
    is_tf_available,
    is_torch_available,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, ArgumentHandler, Dataset, Pipeline, PipelineException


if is_torch_available():
     import torch

     from ..models.auto.modeling_auto import (
         MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
         MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
     )

if is_tf_available() and is_tensorflow_probability_available():
     import tensorflow as tf
     import tensorflow_probability as tfp

     from ..models.auto.modeling_tf_auto import (
         TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
         TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
     )







class 	_snake_case						(   _snake_case							):




     def __call__(	self      ,						_lowerCamelCase=None      ,						_lowerCamelCase=None      ,						**_lowerCamelCase					):
           # Returns tqa_pipeline_inputs of shape:
           # [
           #   {"table": pd.DataFrame, "query": List[str]},
           #   ...,
           #   {"table": pd.DataFrame, "query" : List[str]}
           # ]
           requires_backends(self      ,						'''pandas'''					)
           import pandas as pd

           if table is None:
                 raise ValueError('''Keyword argument `table` cannot be None.'''					)
           elif query is None:
                 if isinstance(_lowerCamelCase      ,						_lowerCamelCase					) and table.get('''query'''					) is not None and table.get('''table'''					) is not None:
                       a		:Union[str, Any]											= [table]
                 elif isinstance(_lowerCamelCase      ,						_lowerCamelCase					) and len(_lowerCamelCase					) > 0:
                       if not all(isinstance(_lowerCamelCase      ,						_lowerCamelCase					) for d in table					):
                             raise ValueError(
                                 F'''Keyword argument `table` should be a list of dict, but is {(type(_lowerCamelCase					) for d in table)}'''					)

                       if table[0].get('''query'''					) is not None and table[0].get('''table'''					) is not None:
                             a		:int											= table
                       else:
                             raise ValueError(
                                 '''If keyword argument `table` is a list of dictionaries, each dictionary should have a `table`'''
                                 F''' and `query` key, but only dictionary has keys {table[0].keys()} `table` and `query` keys.'''					)
                 elif Dataset is not None and isinstance(_lowerCamelCase      ,						_lowerCamelCase					) or isinstance(_lowerCamelCase      ,						types.GeneratorType					):
                       return table
                 else:
                       raise ValueError(
                           '''Invalid input. Keyword argument `table` should be either of type `dict` or `list`, but '''
                           F'''is {type(_lowerCamelCase					)})'''					)
           else:
                 a		:List[str]											= [{'''table''': table, '''query''': query}]

           for tqa_pipeline_input in tqa_pipeline_inputs:
                 if not isinstance(tqa_pipeline_input['''table''']      ,						pd.DataFrame					):
                       if tqa_pipeline_input["table"] is None:
                             raise ValueError('''Table cannot be None.'''					)

                       a		:List[str]											= pd.DataFrame(tqa_pipeline_input['''table''']					)

           return tqa_pipeline_inputs







@add_end_docstrings(_snake_case							)
class 	_snake_case						(   _snake_case							):
     SCREAMING_SNAKE_CASE__   = 'table,query'




     def __init__(	self      ,						_lowerCamelCase=TableQuestionAnsweringArgumentHandler()      ,						*_lowerCamelCase      ,						**_lowerCamelCase					):
           super().__init__(*_lowerCamelCase      ,						**_lowerCamelCase					)
           a		:Optional[Any]											= args_parser

           self.check_model_type(
               dict(
                   TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING.items()
                   + TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING.items()					)
               if self.framework == '''tf'''
               else dict(
                   MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING.items() + MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING.items()					)					)

           a		:Union[str, Any]											= bool(getattr(self.model.config      ,						'''aggregation_labels'''      ,						_lowerCamelCase					)					) and bool(
               getattr(self.model.config      ,						'''num_aggregation_labels'''      ,						_lowerCamelCase					)					)
           a		:Union[str, Any]											= '''tapas''' if hasattr(self.model.config      ,						'''aggregation_labels'''					) else None




     def  SCREAMING_SNAKE_CASE__       (	self      ,						**_lowerCamelCase					):
           return self.model(**_lowerCamelCase					)




     def  SCREAMING_SNAKE_CASE__       (	self      ,						**_lowerCamelCase					):
           if self.framework == "pt":
                 a		:List[str]											= []
                 a		:List[str]											= []
                 a		:Tuple											= None
                 a		:Optional[int]											= inputs['''input_ids'''].shape[0]

                 a		:Any											= inputs['''input_ids'''].to(self.device					)
                 a		:List[Any]											= inputs['''attention_mask'''].to(self.device					)
                 a		:Tuple											= inputs['''token_type_ids'''].to(self.device					)
                 a		:List[Any]											= None

                 for index in range(_lowerCamelCase					):
                       # If sequences have already been processed, the token type IDs will be created according to the previous
                       # answer.
                       if prev_answers is not None:
                             a		:Optional[int]											= token_type_ids_example[:, 3]  # shape (seq_len,)
                             a		:str											= np.zeros_like(prev_labels_example.cpu().numpy()					)  # shape (seq_len,)

                             a		:str											= token_type_ids[index]  # shape (seq_len, 7)
                             for i in range(model_labels.shape[0]					):
                                   a		:List[str]											= token_type_ids_example[:, 0].tolist()[i]
                                   a		:Union[str, Any]											= token_type_ids_example[:, 1].tolist()[i] - 1
                                   a		:List[Any]											= token_type_ids_example[:, 2].tolist()[i] - 1

                                   if row_id >= 0 and col_id >= 0 and segment_id == 1:
                                         a		:Dict											= int(prev_answers[(col_id, row_id)]					)

                             a		:List[str]											= torch.from_numpy(_lowerCamelCase					).type(torch.long					).to(self.device					)

                       a		:Dict											= input_ids[index]
                       a		:Union[str, Any]											= attention_mask[index]  # shape (seq_len,)
                       a		:List[str]											= token_type_ids[index]  # shape (seq_len, 7)
                       a		:int											= self.model(
                           input_ids=input_ids_example.unsqueeze(0					)      ,						attention_mask=attention_mask_example.unsqueeze(0					)      ,						token_type_ids=token_type_ids_example.unsqueeze(0					)      ,						)
                       a		:Optional[int]											= outputs.logits

                       if self.aggregate:
                             all_aggregations.append(outputs.logits_aggregation					)

                       all_logits.append(_lowerCamelCase					)

                       a		:Any											= torch.distributions.Bernoulli(logits=_lowerCamelCase					)
                       a		:int											= dist_per_token.probs * attention_mask_example.type(torch.floataa					).to(
                           dist_per_token.probs.device					)

                       a		:Dict											= collections.defaultdict(_lowerCamelCase					)
                       for i, p in enumerate(probabilities.squeeze().tolist()					):
                             a		:Dict											= token_type_ids_example[:, 0].tolist()[i]
                             a		:Optional[Any]											= token_type_ids_example[:, 1].tolist()[i] - 1
                             a		:Dict											= token_type_ids_example[:, 2].tolist()[i] - 1
                             if col >= 0 and row >= 0 and segment_id == 1:
                                   coords_to_probs[(col, row)].append(_lowerCamelCase					)

                       a		:Tuple											= {key: np.array(coords_to_probs[key]					).mean() > 0.5 for key in coords_to_probs}

                 a		:Union[str, Any]											= torch.cat(tuple(_lowerCamelCase					)      ,						0					)

                 return (logits_batch,) if not self.aggregate else (logits_batch, torch.cat(tuple(_lowerCamelCase					)      ,						0					))
           else:
                 a		:Dict											= []
                 a		:Any											= []
                 a		:Optional[int]											= None
                 a		:Tuple											= inputs['''input_ids'''].shape[0]

                 a		:Tuple											= inputs['''input_ids''']
                 a		:str											= inputs['''attention_mask''']
                 a		:Tuple											= inputs['''token_type_ids'''].numpy()
                 a		:Any											= None

                 for index in range(_lowerCamelCase					):
                       # If sequences have already been processed, the token type IDs will be created according to the previous
                       # answer.
                       if prev_answers is not None:
                             a		:Optional[int]											= token_type_ids_example[:, 3]  # shape (seq_len,)
                             a		:List[str]											= np.zeros_like(_lowerCamelCase      ,						dtype=np.intaa					)  # shape (seq_len,)

                             a		:Union[str, Any]											= token_type_ids[index]  # shape (seq_len, 7)
                             for i in range(model_labels.shape[0]					):
                                   a		:Dict											= token_type_ids_example[:, 0].tolist()[i]
                                   a		:Optional[int]											= token_type_ids_example[:, 1].tolist()[i] - 1
                                   a		:List[Any]											= token_type_ids_example[:, 2].tolist()[i] - 1

                                   if row_id >= 0 and col_id >= 0 and segment_id == 1:
                                         a		:int											= int(prev_answers[(col_id, row_id)]					)

                             a		:Optional[Any]											= model_labels

                       a		:int											= input_ids[index]
                       a		:List[Any]											= attention_mask[index]  # shape (seq_len,)
                       a		:Optional[Any]											= token_type_ids[index]  # shape (seq_len, 7)
                       a		:Any											= self.model(
                           input_ids=np.expand_dims(_lowerCamelCase      ,						axis=0					)      ,						attention_mask=np.expand_dims(_lowerCamelCase      ,						axis=0					)      ,						token_type_ids=np.expand_dims(_lowerCamelCase      ,						axis=0					)      ,						)
                       a		:List[Any]											= outputs.logits

                       if self.aggregate:
                             all_aggregations.append(outputs.logits_aggregation					)

                       all_logits.append(_lowerCamelCase					)

                       a		:Any											= tfp.distributions.Bernoulli(logits=_lowerCamelCase					)
                       a		:int											= dist_per_token.probs_parameter() * tf.cast(_lowerCamelCase      ,						tf.floataa					)

                       a		:Optional[Any]											= collections.defaultdict(_lowerCamelCase					)
                       a		:int											= token_type_ids_example
                       for i, p in enumerate(tf.squeeze(_lowerCamelCase					).numpy().tolist()					):
                             a		:Union[str, Any]											= token_type_ids_example[:, 0].tolist()[i]
                             a		:Union[str, Any]											= token_type_ids_example[:, 1].tolist()[i] - 1
                             a		:Any											= token_type_ids_example[:, 2].tolist()[i] - 1
                             if col >= 0 and row >= 0 and segment_id == 1:
                                   coords_to_probs[(col, row)].append(_lowerCamelCase					)

                       a		:Dict											= {key: np.array(coords_to_probs[key]					).mean() > 0.5 for key in coords_to_probs}

                 a		:str											= tf.concat(tuple(_lowerCamelCase					)      ,						0					)

                 return (logits_batch,) if not self.aggregate else (logits_batch, tf.concat(tuple(_lowerCamelCase					)      ,						0					))




     def __call__(	self      ,						*_lowerCamelCase      ,						**_lowerCamelCase					):
           a		:Tuple											= self._args_parser(*_lowerCamelCase      ,						**_lowerCamelCase					)

           a		:int											= super().__call__(_lowerCamelCase      ,						**_lowerCamelCase					)
           if len(_lowerCamelCase					) == 1:
                 return results[0]
           return results




     def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase=None      ,						_lowerCamelCase=None      ,						_lowerCamelCase=None      ,						**_lowerCamelCase					):
           a		:Optional[int]											= {}
           if padding is not None:
                 a		:List[Any]											= padding
           if truncation is not None:
                 a		:Tuple											= truncation

           a		:str											= {}
           if sequential is not None:
                 a		:List[str]											= sequential
           return preprocess_params, forward_params, {}




     def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase=None      ,						_lowerCamelCase=True      ,						_lowerCamelCase=None					):
           if truncation is None:
                 if self.type == "tapas":
                       a		:List[Any]											= '''drop_rows_to_fit'''
                 else:
                       a		:List[Any]											= '''do_not_truncate'''

           a		:Optional[int]											= pipeline_input['''table'''], pipeline_input['''query''']
           if table.empty:
                 raise ValueError('''table is empty'''					)
           if query is None or query == "":
                 raise ValueError('''query is empty'''					)
           a		:Any											= self.tokenizer(_lowerCamelCase      ,						_lowerCamelCase      ,						return_tensors=self.framework      ,						truncation=_lowerCamelCase      ,						padding=_lowerCamelCase					)
           a		:Tuple											= table
           return inputs




     def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase      ,						_lowerCamelCase=False					):
           a		:List[str]											= model_inputs.pop('''table'''					)

           if self.type == "tapas":
                 if sequential:
                       a		:List[Any]											= self.sequential_inference(**_lowerCamelCase					)
                 else:
                       a		:str											= self.batch_inference(**_lowerCamelCase					)
           else:
                 a		:Any											= self.model.generate(**_lowerCamelCase					)
           a		:Union[str, Any]											= {'''model_inputs''': model_inputs, '''table''': table, '''outputs''': outputs}
           return model_outputs




     def  SCREAMING_SNAKE_CASE__       (	self      ,						_lowerCamelCase					):
           a		:Optional[Any]											= model_outputs['''model_inputs''']
           a		:int											= model_outputs['''table''']
           a		:Optional[int]											= model_outputs['''outputs''']
           if self.type == "tapas":
                 if self.aggregate:
                       a		:Tuple											= outputs[:2]
                       a		:Optional[int]											= self.tokenizer.convert_logits_to_predictions(_lowerCamelCase      ,						_lowerCamelCase      ,						_lowerCamelCase					)
                       a		:int											= predictions
                       a		:Optional[Any]											= {i: self.model.config.aggregation_labels[pred] for i, pred in enumerate(_lowerCamelCase					)}

                       a		:List[str]											= self.model.config.no_aggregation_label_index
                       a		:Dict											= {
                           i: aggregators[i] + ''' > ''' for i, pred in enumerate(_lowerCamelCase					) if pred != no_agg_label_index
                       }
                 else:
                       a		:Any											= outputs[0]
                       a		:Any											= self.tokenizer.convert_logits_to_predictions(_lowerCamelCase      ,						_lowerCamelCase					)
                       a		:List[Any]											= predictions[0]
                       a		:List[str]											= {}
                       a		:int											= {}
                 a		:Tuple											= []
                 for index, coordinates in enumerate(_lowerCamelCase					):
                       a		:Any											= [table.iat[coordinate] for coordinate in coordinates]
                       a		:Union[str, Any]											= aggregators.get(_lowerCamelCase      ,						''''''					)
                       a		:Optional[Any]											= aggregators_prefix.get(_lowerCamelCase      ,						''''''					)
                       a		:List[Any]											= {
                           '''answer''': aggregator_prefix + ''', '''.join(_lowerCamelCase					),
                           '''coordinates''': coordinates,
                           '''cells''': [table.iat[coordinate] for coordinate in coordinates],
                       }
                       if aggregator:
                             a		:Tuple											= aggregator

                       answers.append(_lowerCamelCase					)
                 if len(_lowerCamelCase					) == 0:
                       raise PipelineException('''Empty answer'''					)
           else:
                 a		:Optional[int]											= [{'''answer''': answer} for answer in self.tokenizer.batch_decode(_lowerCamelCase      ,						skip_special_tokens=_lowerCamelCase					)]

           return answers if len(_lowerCamelCase					) > 1 else answers[0]









import warnings

from ...utils import logging
from .image_processing_convnext import ConvNextImageProcessor


snake_case       :					Tuple        =  logging.get_logger(__name__)







class 	_snake_case						(   _snake_case							):




 def __init__(	self      ,						*_lowerCamelCase      ,						**_lowerCamelCase					):
       warnings.warn(
           '''The class ConvNextFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'''
           ''' Please use ConvNextImageProcessor instead.'''      ,						_lowerCamelCase      ,						)
       super().__init__(*_lowerCamelCase      ,						**_lowerCamelCase					)





