




import html

from ...feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from ...utils import is_bsa_available, logging, requires_backends


if is_bsa_available():
					import bsa
					from bsa import BeautifulSoup


UpperCamelCase__					    =    logging.get_logger(__name__)
class     a__					(      snake_case__   ):






						def __init__(     self	,    **_A    ):




											"""simple docstring"""



											requires_backends(self	,    ["bs4"]    )
											super().__init__(**_A    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = []
											__lowerCAmelCase            = []
											__lowerCAmelCase            = element if element.name else element.parent
											for parent in child.parents:  # type: bs4.element.Tag
																__lowerCAmelCase            = parent.find_all(child.name	,    recursive=_A    )
																xpath_tags.append(child.name    )
																xpath_subscripts.append(
																    0 if 1 == len(_A    ) else next(i for i, s in enumerate(_A	,    1    ) if s is child    )    )
																__lowerCAmelCase            = parent
											xpath_tags.reverse()
											xpath_subscripts.reverse()
											return xpath_tags, xpath_subscripts






						def        __SCREAMING_SNAKE_CASE(     self	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = BeautifulSoup(_A	,    "html.parser"    )

											__lowerCAmelCase            = []
											__lowerCAmelCase            = []
											__lowerCAmelCase            = []

											for element in html_code.descendants:
																if type(_A    ) == bsa.element.NavigableString:
																					if type(element.parent    ) != bsa.element.Tag:
																										continue

																					__lowerCAmelCase            = html.unescape(_A    ).strip()
																					if not text_in_this_tag:
																										continue

																					all_doc_strings.append(_A    )

																					__lowerCAmelCase     ,							__lowerCAmelCase            = self.xpath_soup(_A    )
																					stringaxtag_seq.append(_A    )
																					stringaxsubs_seq.append(_A    )

											if len(_A    ) != len(_A    ):
																raise ValueError("Number of doc strings and xtags does not correspond"    )
											if len(_A    ) != len(_A    ):
																raise ValueError("Number of doc strings and xsubs does not correspond"    )

											return all_doc_strings, stringaxtag_seq, stringaxsubs_seq






						def        __SCREAMING_SNAKE_CASE(     self	,    _A	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = ""
											for tagname, subs in zip(_A	,    _A    ):
																xpath += f"""/{tagname}"""
																if subs != 0:
																					xpath += f"""[{subs}]"""
											return xpath






						def __call__(     self	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = False

											# Check that strings has a valid type
											if isinstance(_A	,    _A    ):
																__lowerCAmelCase            = True
											elif isinstance(_A	,    (list, tuple)    ):
																if len(_A    ) == 0 or isinstance(html_strings[0]	,    _A    ):
																					__lowerCAmelCase            = True

											if not valid_strings:
																raise ValueError(
																    "HTML strings must of type `str`, `List[str]` (batch of examples), "
																    f"""but is of type {type(_A    )}."""    )

											__lowerCAmelCase            = bool(isinstance(_A	,    (list, tuple)    ) and (isinstance(html_strings[0]	,    _A    ))    )

											if not is_batched:
																__lowerCAmelCase            = [html_strings]

											# Get nodes + xpaths
											__lowerCAmelCase            = []
											__lowerCAmelCase            = []
											for html_string in html_strings:
																__lowerCAmelCase     ,							__lowerCAmelCase     ,							__lowerCAmelCase            = self.get_three_from_single(_A    )
																nodes.append(_A    )
																__lowerCAmelCase            = []
																for node, tag_list, sub_list in zip(_A	,    _A	,    _A    ):
																					__lowerCAmelCase            = self.construct_xpath(_A	,    _A    )
																					xpath_strings.append(_A    )
																xpaths.append(_A    )

											# return as Dict
											__lowerCAmelCase            = {"nodes": nodes, "xpaths": xpaths}
											__lowerCAmelCase            = BatchFeature(data=_A	,    tensor_type=_A    )

											return encoded_inputs










from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
					from PIL import Image

					from ..image_utils import load_image

if is_tf_available():
					import tensorflow as tf

					from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
					from ..tf_utils import stable_softmax

if is_torch_available():
					from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING

UpperCamelCase__					    =    logging.get_logger(__name__)
@add_end_docstrings(snake_case__   )
class     a__					(      snake_case__   ):






						def __init__(     self	,    *_A	,    **_A    ):




											"""simple docstring"""



											super().__init__(*_A	,    **_A    )
											requires_backends(self	,    "vision"    )
											self.check_model_type(
											    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
											    if self.framework == "tf"
											    else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A=None    ):




											"""simple docstring"""



											__lowerCAmelCase            = {}
											if top_k is not None:
																__lowerCAmelCase            = top_k
											return {}, {}, postprocess_params






						def __call__(     self	,    _A	,    **_A    ):




											"""simple docstring"""



											return super().__call__(_A	,    **_A    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = load_image(_A    )
											__lowerCAmelCase            = self.image_processor(images=_A	,    return_tensors=self.framework    )
											return model_inputs






						def        __SCREAMING_SNAKE_CASE(     self	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.model(**_A    )
											return model_outputs






						def        __SCREAMING_SNAKE_CASE(     self	,    _A	,    _A=5    ):




											"""simple docstring"""



											if top_k > self.model.config.num_labels:
																__lowerCAmelCase            = self.model.config.num_labels

											if self.framework == "pt":
																__lowerCAmelCase            = model_outputs.logits.softmax(-1    )[0]
																__lowerCAmelCase     ,							__lowerCAmelCase            = probs.topk(_A    )
											elif self.framework == "tf":
																__lowerCAmelCase            = stable_softmax(model_outputs.logits	,    axis=-1    )[0]
																__lowerCAmelCase            = tf.math.top_k(_A	,    k=_A    )
																__lowerCAmelCase     ,							__lowerCAmelCase            = topk.values.numpy(), topk.indices.numpy()
											else:
																raise ValueError(f"""Unsupported framework: {self.framework}"""    )

											__lowerCAmelCase            = scores.tolist()
											__lowerCAmelCase            = ids.tolist()
											return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(_A	,    _A    )]




