
"""simple docstring"""


from __future__ import annotations

import requests






def 					_snake_case (						snake_case__      :   str   ):
	A        =      F'https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty'
	return requests.get(snake_case__   ).json()






def 					_snake_case (						snake_case__      :   int = 10   ):
	A        =      'https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty'
	A        =      requests.get(snake_case__   ).json()[:max_stories]
	return [get_hackernews_story(snake_case__   ) for story_id in story_ids]






def 					_snake_case (						snake_case__      :   int = 10   ):
	A        =      hackernews_top_stories(snake_case__   )
	return "\n".join('* [{title}]({url})'.format(**snake_case__   ) for story in stories   )


if __name__ == "__main__":
		print(hackernews_top_stories_as_markdown())


import math
from typing import Dict, Iterable, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    is_torch_available,
    is_torch_tensor,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_torch_available():
 import torch

if is_vision_available():
 import PIL


_UpperCamelCase 			=		logging.get_logger(__name__)







def 		_lowercase (     lowercase__   ,	lowercase__   ,	lowercase__   ,	lowercase__						):
      def constraint_to_multiple_of(lowercase__   ,	lowercase__   ,	lowercase__=0   ,	lowercase__=None						):
            __lowerCAmelCase					:						int					=					round(val / multiple						) * multiple

            if max_val is not None and x > max_val:
                  __lowerCAmelCase					:						Optional[int]					=					math.floor(val / multiple						) * multiple

            if x < min_val:
                  __lowerCAmelCase					:						Any					=					math.ceil(val / multiple						) * multiple

            return x

      __lowerCAmelCase					:						Dict					=					(output_size, output_size) if isinstance(lowercase__   ,	lowercase__						) else output_size

      __lowerCAmelCase,							__lowerCAmelCase					:						Optional[Any]					=					get_image_size(lowercase__						)
      __lowerCAmelCase,							__lowerCAmelCase					:						int					=					output_size

      # determine new height and width
      __lowerCAmelCase					:						Optional[Any]					=					output_height / input_height
      __lowerCAmelCase					:						List[Any]					=					output_width / input_width

      if keep_aspect_ratio:
            # scale as little as possible
            if abs(1 - scale_width						) < abs(1 - scale_height						):
                  # fit width
                  __lowerCAmelCase					:						str					=					scale_width
            else:
                  # fit height
                  __lowerCAmelCase					:						str					=					scale_height

      __lowerCAmelCase					:						Any					=					constraint_to_multiple_of(scale_height * input_height   ,	multiple=lowercase__						)
      __lowerCAmelCase					:						Union[str, Any]					=					constraint_to_multiple_of(scale_width * input_width   ,	multiple=lowercase__						)

      return (new_height, new_width)







class   __lowercase      (_UpperCAmelCase ):
 _UpperCamelCase			  =  ["""pixel_values"""]
 def __init__(							self      ,							A_ = True      ,							A_ = None      ,							A_ = PILImageResampling.BILINEAR      ,							A_ = False      ,							A_ = 1      ,							A_ = True      ,							A_ = 1 / 255      ,							A_ = True      ,							A_ = None      ,							A_ = None      ,							**A_      ,							)					->None:



       '''simple docstring'''





       super().__init__(**A_					)
       __lowerCAmelCase					:						Union[str, Any]					=					size if size is not None else {'''height''': 384, '''width''': 384}
       __lowerCAmelCase					:						Dict					=					get_size_dict(A_					)
       __lowerCAmelCase					:						Optional[Any]					=					do_resize
       __lowerCAmelCase					:						int					=					size
       __lowerCAmelCase					:						Dict					=					keep_aspect_ratio
       __lowerCAmelCase					:						List[Any]					=					ensure_multiple_of
       __lowerCAmelCase					:						Tuple					=					resample
       __lowerCAmelCase					:						Dict					=					do_rescale
       __lowerCAmelCase					:						Any					=					rescale_factor
       __lowerCAmelCase					:						List[Any]					=					do_normalize
       __lowerCAmelCase					:						Optional[int]					=					image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
       __lowerCAmelCase					:						Optional[int]					=					image_std if image_std is not None else IMAGENET_STANDARD_STD
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_ = False      ,							A_ = 1      ,							A_ = PILImageResampling.BICUBIC      ,							A_ = None      ,							**A_      ,							)					->np.ndarray:



       '''simple docstring'''





       __lowerCAmelCase					:						int					=					get_size_dict(A_					)
       if "height" not in size or "width" not in size:
             raise ValueError(f"""The size dictionary must contain the keys 'height' and 'width'. Got {size.keys()}"""					)
       __lowerCAmelCase					:						Union[str, Any]					=					get_resize_output_image_size(
           A_      ,							output_size=(size['''height'''], size['''width'''])      ,							keep_aspect_ratio=A_      ,							multiple=A_      ,							)
       return resize(A_      ,							size=A_      ,							resample=A_      ,							data_format=A_      ,							**A_					)
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_ = None      ,							**A_      ,							)					->Dict:



       '''simple docstring'''





       return rescale(A_      ,							scale=A_      ,							data_format=A_      ,							**A_					)
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_      ,							A_ = None      ,							**A_      ,							)					->np.ndarray:



       '''simple docstring'''





       return normalize(A_      ,							mean=A_      ,							std=A_      ,							data_format=A_      ,							**A_					)
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = ChannelDimension.FIRST      ,							**A_      ,							)					->PIL.Image.Image:



       '''simple docstring'''





       __lowerCAmelCase					:						int					=					do_resize if do_resize is not None else self.do_resize
       __lowerCAmelCase					:						Optional[int]					=					size if size is not None else self.size
       __lowerCAmelCase					:						Union[str, Any]					=					get_size_dict(A_					)
       __lowerCAmelCase					:						List[Any]					=					keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio
       __lowerCAmelCase					:						Optional[int]					=					ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of
       __lowerCAmelCase					:						Tuple					=					resample if resample is not None else self.resample
       __lowerCAmelCase					:						Optional[int]					=					do_rescale if do_rescale is not None else self.do_rescale
       __lowerCAmelCase					:						Union[str, Any]					=					rescale_factor if rescale_factor is not None else self.rescale_factor
       __lowerCAmelCase					:						Tuple					=					do_normalize if do_normalize is not None else self.do_normalize
       __lowerCAmelCase					:						str					=					image_mean if image_mean is not None else self.image_mean
       __lowerCAmelCase					:						Optional[Any]					=					image_std if image_std is not None else self.image_std

       __lowerCAmelCase					:						Optional[Any]					=					make_list_of_images(A_					)

       if not valid_images(A_					):
             raise ValueError(
                 '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
                 '''torch.Tensor, tf.Tensor or jax.ndarray.'''					)

       if do_resize and size is None or resample is None:
             raise ValueError('''Size and resample must be specified if do_resize is True.'''					)

       if do_rescale and rescale_factor is None:
             raise ValueError('''Rescale factor must be specified if do_rescale is True.'''					)

       if do_normalize and (image_mean is None or image_std is None):
             raise ValueError('''Image mean and std must be specified if do_normalize is True.'''					)

       # All transformations expect numpy arrays.
       __lowerCAmelCase					:						Any					=					[to_numpy_array(A_					) for image in images]

       if do_resize:
             __lowerCAmelCase					:						Optional[Any]					=					[self.resize(image=A_      ,							size=A_      ,							resample=A_					) for image in images]

       if do_rescale:
             __lowerCAmelCase					:						Tuple					=					[self.rescale(image=A_      ,							scale=A_					) for image in images]

       if do_normalize:
             __lowerCAmelCase					:						str					=					[self.normalize(image=A_      ,							mean=A_      ,							std=A_					) for image in images]

       __lowerCAmelCase					:						Union[str, Any]					=					[to_channel_dimension_format(A_      ,							A_					) for image in images]

       __lowerCAmelCase					:						Dict					=					{'''pixel_values''': images}
       return BatchFeature(data=A_      ,							tensor_type=A_					)





 def 	UpperCamelCase__  (							self      ,							A_      ,							A_ = None					)					->Any:



       '''simple docstring'''





       __lowerCAmelCase					:						Any					=					outputs.logits

       # Resize logits and compute semantic segmentation maps
       if target_sizes is not None:
             if len(A_					) != len(A_					):
                   raise ValueError(
                       '''Make sure that you pass in as many target sizes as the batch dimension of the logits'''					)

             if is_torch_tensor(A_					):
                   __lowerCAmelCase					:						Optional[int]					=					target_sizes.numpy()

             __lowerCAmelCase					:						List[str]					=					[]

             for idx in range(len(A_					)					):
                   __lowerCAmelCase					:						Any					=					torch.nn.functional.interpolate(
                       logits[idx].unsqueeze(dim=0					)      ,							size=target_sizes[idx]      ,							mode='''bilinear'''      ,							align_corners=A_					)
                   __lowerCAmelCase					:						str					=					resized_logits[0].argmax(dim=0					)
                   semantic_segmentation.append(A_					)
       else:
             __lowerCAmelCase					:						Any					=					logits.argmax(dim=1					)
             __lowerCAmelCase					:						List[Any]					=					[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]					)]

       return semantic_segmentation


