



# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING, Dict, Optional

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.logging import get_logger
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
     import jax
     import jaxlib

a_      :      Dict    =     get_logger()

a_      :      Optional[dict]    =     None
class    __UpperCamelCase			(       TensorFormatter[Mapping, '''jax.Array''', Mapping]				):

 """simple docstring"""



 def __init__(	self		,				SCREAMING_SNAKE_CASE=None		,				SCREAMING_SNAKE_CASE=None		,				**SCREAMING_SNAKE_CASE      ) ->			Union[str, Any]:
  super().__init__(features=SCREAMING_SNAKE_CASE      )
  import jax
  from jaxlib.xla_client import Device

  if isinstance(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ):
   raise ValueError(
       f"Expected {device} to be a `str` not {type(SCREAMING_SNAKE_CASE      )}, as `jaxlib.xla_extension.Device` "
       '''is not serializable neither with `pickle` nor with `dill`. Instead you can surround '''
       '''the device with `str()` to get its string identifier that will be internally mapped '''
       '''to the actual `jaxlib.xla_extension.Device`.'''      )
  a__												= device if isinstance(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) else str(jax.devices()[0]      )
  # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
  # with `pickle` nor with `dill`, so we need to use a global variable instead
  global DEVICE_MAPPING
  if DEVICE_MAPPING is None:
   a__												= self._map_devices_to_str()
  if self.device not in list(DEVICE_MAPPING.keys()      ):
   logger.warning(
       f"Device with string identifier {self.device} not listed among the available "
       f"devices: {list(DEVICE_MAPPING.keys()      )}, so falling back to the default "
       f"device: {str(jax.devices()[0]      )}."      )
   a__												= str(jax.devices()[0]      )
  a__												= jnp_array_kwargs

 @staticmethod
 def 						_UpperCAmelCase       (	) ->			Dict[str, "jaxlib.xla_extension.Device"]:
  import jax

  return {str(SCREAMING_SNAKE_CASE      ): device for device in jax.devices()}

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			str:
  import jax
  import jax.numpy as jnp

  if isinstance(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE      ) and column:
   if all(
       isinstance(SCREAMING_SNAKE_CASE		,				jax.Array      ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column      ):
    return jnp.stack(SCREAMING_SNAKE_CASE		,				axis=0      )
  return column

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			Any:
  import jax
  import jax.numpy as jnp

  if isinstance(SCREAMING_SNAKE_CASE		,				(str, bytes, type(SCREAMING_SNAKE_CASE      ))      ):
   return value
  elif isinstance(SCREAMING_SNAKE_CASE		,				(np.character, np.ndarray)      ) and np.issubdtype(value.dtype		,				np.character      ):
   return value.tolist()

  a__												= {}

  if isinstance(SCREAMING_SNAKE_CASE		,				(np.number, np.ndarray)      ) and np.issubdtype(value.dtype		,				np.integer      ):
   # the default int precision depends on the jax config
   # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
   if jax.config.jax_enable_xaa:
    a__												= {'''dtype''': jnp.intaa}
   else:
    a__												= {'''dtype''': jnp.intaa}
  elif isinstance(SCREAMING_SNAKE_CASE		,				(np.number, np.ndarray)      ) and np.issubdtype(value.dtype		,				np.floating      ):
   a__												= {'''dtype''': jnp.floataa}
  elif config.PIL_AVAILABLE and "PIL" in sys.modules:
   import PIL.Image

   if isinstance(SCREAMING_SNAKE_CASE		,				PIL.Image.Image      ):
    a__												= np.asarray(SCREAMING_SNAKE_CASE      )

        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
        # with `pickle` nor with `dill`, so we need to use a global variable instead
  global DEVICE_MAPPING
  if DEVICE_MAPPING is None:
   a__												= self._map_devices_to_str()

  with jax.default_device(DEVICE_MAPPING[self.device]      ):
   # calling jnp.array on a np.ndarray does copy the data
   # see https://github.com/google/jax/issues/4486
   return jnp.array(SCREAMING_SNAKE_CASE		,				**{**default_dtype, **self.jnp_array_kwargs}      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			str:
  import jax

  # support for torch, tf, jax etc.
  if config.TORCH_AVAILABLE and "torch" in sys.modules:
   import torch

   if isinstance(SCREAMING_SNAKE_CASE		,				torch.Tensor      ):
    return self._tensorize(data_struct.detach().cpu().numpy()[()]      )
  if hasattr(SCREAMING_SNAKE_CASE		,				'''__array__'''      ) and not isinstance(SCREAMING_SNAKE_CASE		,				jax.Array      ):
   a__												= data_struct.__array__()
  # support for nested types like struct of list of struct
  if isinstance(SCREAMING_SNAKE_CASE		,				np.ndarray      ):
   if data_struct.dtype == object:  # jax arrays cannot be instantied from an array of objects
    return self._consolidate([self.recursive_tensorize(SCREAMING_SNAKE_CASE      ) for substruct in data_struct]      )
  elif isinstance(SCREAMING_SNAKE_CASE		,				(list, tuple)      ):
   return self._consolidate([self.recursive_tensorize(SCREAMING_SNAKE_CASE      ) for substruct in data_struct]      )
  return self._tensorize(SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			Tuple:
  return map_nested(self._recursive_tensorize		,				SCREAMING_SNAKE_CASE		,				map_list=SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			Mapping:
  a__												= self.numpy_arrow_extractor().extract_row(SCREAMING_SNAKE_CASE      )
  a__												= self.python_features_decoder.decode_row(SCREAMING_SNAKE_CASE      )
  return self.recursive_tensorize(SCREAMING_SNAKE_CASE      )

 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			"jax.Array":
  a__												= self.numpy_arrow_extractor().extract_column(SCREAMING_SNAKE_CASE      )
  a__												= self.python_features_decoder.decode_column(SCREAMING_SNAKE_CASE		,				pa_table.column_names[0]      )
  a__												= self.recursive_tensorize(SCREAMING_SNAKE_CASE      )
  a__												= self._consolidate(SCREAMING_SNAKE_CASE      )
  return column



 def 						_UpperCAmelCase       (	self		,				SCREAMING_SNAKE_CASE      ) ->			Mapping:
  a__												= self.numpy_arrow_extractor().extract_batch(SCREAMING_SNAKE_CASE      )
  a__												= self.python_features_decoder.decode_batch(SCREAMING_SNAKE_CASE      )
  a__												= self.recursive_tensorize(SCREAMING_SNAKE_CASE      )
  for column_name in batch:
   a__												= self._consolidate(batch[column_name]      )
  return batch










from __future__ import annotations

import requests






def     __a					(		__UpperCAmelCase       ):
 a__												= f"https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty"
 return requests.get(__UpperCAmelCase       ).json()






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






def     __a					(		__UpperCAmelCase = 10       ):
 a__												= hackernews_top_stories(__UpperCAmelCase       )
 return "\n".join('''* [{title}]({url})'''.format(**__UpperCAmelCase       ) for story in stories       )


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





