code: def get_conv_block(
      spatial_dims: int,
      in_channels: int,
      out_channels: int,
      kernel_size: Sequence[int] | int = 3,
      strides: int = 1,
      padding: tuple[int, ...] | int | None = None,
      act: tuple | str | None = "RELU",
      norm: tuple | str | None = "BATCH",
      initializer: str | None = "kaiming_uniform",
  ) -> nn.Module:
      if padding is None:
          padding = same_padding(kernel_size)
      conv_block: nn.Module = Convolution(
          spatial_dims,
          in_channels,
          out_channels,
          kernel_size=kernel_size,
          strides=strides,
          act=act,
          norm=norm,
          bias=False,
          conv_only=False,
          padding=padding,
      )
      conv_type: type[nn.Conv1d | nn.Conv2d | nn.Conv3d] = Conv[
          Conv.CONV, spatial_dims
      ]
      for m in conv_block.modules():
          if isinstance(m, conv_type):
              if initializer == "kaiming_uniform":
                  nn.init.kaiming_normal_(torch.as_tensor(m.weight))
              elif initializer == "zeros":
                  nn.init.zeros_(torch.as_tensor(m.weight))
              else:
                  raise ValueError(
                      f"initializer {initializer} is not supported, "
                      "currently supporting kaiming_uniform and zeros"
                  )
      return conv_block
  
imports: from __future__ import annotations
  from collections.abc import Sequence
  import torch
  from torch import nn
  from torch.nn import functional
  from monai.networks.blocks import Convolution
  from monai.networks.layers import Conv, Norm, Pool, same_padding
label_desc: Use image node_id 1 for calling a global function with example usage: get_conv_block(spatial_dims, in_channels, out_channels, kernel_size, strides, padding, act, norm, initializer) and returns: conv_block