

"""simple docstring"""
# 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							=  get_logger()

_A							=  None

class       lowerCamelCase	(       TensorFormatter[Mapping, 'jax.Array', Mapping]   ):


  '''simple docstring'''







  def __init__(self							,       _lowerCamelCase=None							,       _lowerCamelCase=None							,       **_lowerCamelCase	):


        """simple docstring"""

        super().__init__(features=_lowerCamelCase	)
        import jax
        from jaxlib.xla_client import Device

        if isinstance(_lowerCamelCase							,       _lowerCamelCase	):
              raise ValueError(
                  F"""Expected {device} to be a `str` not {type(_lowerCamelCase	)}, 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`."""	)
        UpperCAmelCase__			:							Optional[Any]							=    device if isinstance(_lowerCamelCase							,       _lowerCamelCase	) 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:
              UpperCAmelCase__			:							Tuple							=    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]	)}."""	)
              UpperCAmelCase__			:							Tuple							=    str(jax.devices()[0]	)
        UpperCAmelCase__			:							Any							=    jnp_array_kwargs



  @staticmethod
  def  _a      ():


        """simple docstring"""

        import jax

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



  def  _a      (self							,       _lowerCamelCase	):


        """simple docstring"""

        import jax
        import jax.numpy as jnp

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



  def  _a      (self							,       _lowerCamelCase	):


        """simple docstring"""

        import jax
        import jax.numpy as jnp

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

        UpperCAmelCase__			:							str							=    {}

        if isinstance(_lowerCamelCase							,       (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:
                    UpperCAmelCase__			:							Optional[int]							=    {"""dtype""": jnp.intaa}
              else:
                    UpperCAmelCase__			:							Any							=    {"""dtype""": jnp.intaa}
        elif isinstance(_lowerCamelCase							,       (np.number, np.ndarray)	) and np.issubdtype(value.dtype							,       np.floating	):
              UpperCAmelCase__			:							Dict							=    {"""dtype""": jnp.floataa}
        elif config.PIL_AVAILABLE and "PIL" in sys.modules:
              import PIL.Image

              if isinstance(_lowerCamelCase							,       PIL.Image.Image	):
                    UpperCAmelCase__			:							List[Any]							=    np.asarray(_lowerCamelCase	)

        # 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:
              UpperCAmelCase__			:							Optional[int]							=    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(_lowerCamelCase							,       **{**default_dtype, **self.jnp_array_kwargs}	)



  def  _a      (self							,       _lowerCamelCase	):


        """simple docstring"""

        import jax

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

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



  def  _a      (self							,       _lowerCamelCase	):


        """simple docstring"""

        return map_nested(self._recursive_tensorize							,       _lowerCamelCase							,       map_list=_lowerCamelCase	)



  def  _a      (self							,       _lowerCamelCase	):


        """simple docstring"""

        UpperCAmelCase__			:							Dict							=    self.numpy_arrow_extractor().extract_row(_lowerCamelCase	)
        UpperCAmelCase__			:							Optional[int]							=    self.python_features_decoder.decode_row(_lowerCamelCase	)
        return self.recursive_tensorize(_lowerCamelCase	)



  def  _a      (self							,       _lowerCamelCase	):


        """simple docstring"""

        UpperCAmelCase__			:							Optional[int]							=    self.numpy_arrow_extractor().extract_column(_lowerCamelCase	)
        UpperCAmelCase__			:							int							=    self.python_features_decoder.decode_column(_lowerCamelCase							,       pa_table.column_names[0]	)
        UpperCAmelCase__			:							int							=    self.recursive_tensorize(_lowerCamelCase	)
        UpperCAmelCase__			:							Optional[int]							=    self._consolidate(_lowerCamelCase	)
        return column




  def  _a      (self							,       _lowerCamelCase	):


        """simple docstring"""

        UpperCAmelCase__			:							Optional[Any]							=    self.numpy_arrow_extractor().extract_batch(_lowerCamelCase	)
        UpperCAmelCase__			:							Optional[Any]							=    self.python_features_decoder.decode_batch(_lowerCamelCase	)
        UpperCAmelCase__			:							Tuple							=    self.recursive_tensorize(_lowerCamelCase	)
        for column_name in batch:
              UpperCAmelCase__			:							Union[str, Any]							=    self._consolidate(batch[column_name]	)
        return batch




"""simple docstring"""
from __future__ import annotations

from functools import lru_cache
from math import ceil

_A							=  1_00

_A							=  set(range(3, NUM_PRIMES, 2))
primes.add(2)
_A							=  42

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
    if prime not in primes:
        continue
    primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))




@lru_cache(maxsize=1_00    )
def 					a__						(						lowerCAmelCase    )	-> set[int]:
      if number_to_partition < 0:
            return set()
      elif number_to_partition == 0:
            return {1}

      UpperCAmelCase__			:							set[int]							=    set()
      UpperCAmelCase__			:							int
      UpperCAmelCase__			:							int

      for prime in primes:
            if prime > number_to_partition:
                  continue
            for sub in partition(number_to_partition - prime    ):
                  ret.add(sub * prime    )

      return ret




def 					a__						(						lowerCAmelCase = 50_00    )	-> int | None:
      for number_to_partition in range(1			,	lowerCAmelCase    ):
            if len(partition(lowerCAmelCase    )    ) > number_unique_partitions:
                  return number_to_partition
      return None


if __name__ == "__main__":
    print(f'''{solution() = }''')

