code: def obtain_input_shape(
      input_shape,
      default_size,
      min_size,
      data_format,
      require_flatten,
      weights=None,
  ):
      """Internal utility to compute/validate a model's input shape.
  
      Args:
        input_shape: Either None (will return the default network input shape),
          or a user-provided shape to be validated.
        default_size: Default input width/height for the model.
        min_size: Minimum input width/height accepted by the model.
        data_format: Image data format to use.
        require_flatten: Whether the model is expected to
          be linked to a classifier via a Flatten layer.
        weights: One of `None` (random initialization)
          or 'imagenet' (pre-training on ImageNet).
          If weights='imagenet' input channels must be equal to 3.
  
      Returns:
        An integer shape tuple (may include None entries).
  
      Raises:
        ValueError: In case of invalid argument values.
      """
      if (
          weights != "imagenet"
          and input_shape
          and len(input_shape) == 3
      ):
          if data_format == "channels_first":
              correct_channel_axis = 1 if len(input_shape) == 4 else 0
              if input_shape[correct_channel_axis] not in {1, 3}:
                  warnings.warn(
                      "This model usually expects 1 or 3 input channels. "
                      "However, it was passed an input_shape "
                      f"with {input_shape[0]} input channels.",
                      stacklevel=2,
                  )
              default_shape = (
                  input_shape[0],
                  default_size,
                  default_size,
              )
          else:
              if input_shape[-1] not in {1, 3}:
                  warnings.warn(
                      "This model usually expects 1 or 3 input channels. "
                      "However, it was passed an input_shape "
                      f"with {input_shape[-1]} input channels.",
                      stacklevel=2,
                  )
              default_shape = (
                  default_size,
                  default_size,
                  input_shape[-1],
              )
      else:
          if data_format == "channels_first":
              default_shape = (3, default_size, default_size)
          else:
              default_shape = (default_size, default_size, 3)
      if weights == "imagenet" and require_flatten:
          if input_shape is not None:
              if input_shape != default_shape:
                  raise ValueError(
                      "When setting `include_top=True` "
                      "and loading `imagenet` weights, "
                      f"`input_shape` should be {default_shape}.  "
                      f"Received: input_shape={input_shape}"
                  )
          return default_shape
      if input_shape:
          if data_format == "channels_first":
              if input_shape is not None:
                  if len(input_shape) != 3:
                      raise ValueError(
                          "`input_shape` must be a tuple of three integers."
                      )
                  if input_shape[0] != 3 and weights == "imagenet":
                      raise ValueError(
                          "The input must have 3 channels; Received "
                          f"`input_shape={input_shape}`"
                      )
                  if (
                      input_shape[1] is not None
                      and input_shape[1] < min_size
                  ) or (
                      input_shape[2] is not None
                      and input_shape[2] < min_size
                  ):
                      raise ValueError(
                          f"Input size must be at least {min_size}"
                          f"x{min_size}; Received: "
                          f"input_shape={input_shape}"
                      )
          else:
              if input_shape is not None:
                  if len(input_shape) != 3:
                      raise ValueError(
                          "`input_shape` must be a tuple of three integers."
                      )
                  if input_shape[-1] != 3 and weights == "imagenet":
                      raise ValueError(
                          "The input must have 3 channels; Received "
                          f"`input_shape={input_shape}`"
                      )
                  if (
                      input_shape[0] is not None
                      and input_shape[0] < min_size
                  ) or (
                      input_shape[1] is not None
                      and input_shape[1] < min_size
                  ):
                      raise ValueError(
                          "Input size must be at least "
                          f"{min_size}x{min_size}; Received: "
                          f"input_shape={input_shape}"
                      )
      else:
          if require_flatten:
              input_shape = default_shape
          else:
              if data_format == "channels_first":
                  input_shape = (3, None, None)
              else:
                  input_shape = (None, None, 3)
      if require_flatten:
          if None in input_shape:
              raise ValueError(
                  "If `include_top` is True, "
                  "you should specify a static `input_shape`. "
                  f"Received: input_shape={input_shape}"
              )
      return input_shape
  
file_path: keras/keras/applications/imagenet_utils.py
imports: import json
  import warnings
  import numpy
  from keras import activations
  from keras import backend
  from keras import ops
  from keras.api_export import keras_export
  from keras.utils import file_utils
label_desc: Use image node_id 5 for calling a global function with example usage: obtain_input_shape(input_shape, default_size, min_size, data_format, require_flatten, weights) and returns: input_shape, default_shape