code: def get_filtered_transforms(
      base_classes: typing.Tuple[typing.Type, ...],
      custom_arguments: typing.Optional[
          typing.Dict[typing.Type, dict]
      ] = None,
      except_augmentations: typing.Optional[
          typing.Set[typing.Type]
      ] = None,
  ) -> typing.List[typing.Tuple[typing.Type, dict]]:
      custom_arguments = custom_arguments or {}
      except_augmentations = except_augmentations or set()
  
      result = []
  
      for name, cls in inspect.getmembers(albumentations):
          if not inspect.isclass(cls) or not issubclass(
              cls,
              (
                  albumentations.BasicTransform,
                  albumentations.BaseCompose,
              ),
          ):
              continue
  
          if "DeprecationWarning" in inspect.getsource(
              cls
          ) or "FutureWarning" in inspect.getsource(cls):
              continue
  
          if (
              not issubclass(cls, base_classes)
              or any(cls == i for i in base_classes)
              or cls in except_augmentations
          ):
              continue
  
          try:
              if issubclass(cls, albumentations.BasicIAATransform):
                  continue
          except AttributeError:
              pass
  
          result.append((cls, custom_arguments.get(cls, {})))
  
      return result
  
imports: import inspect
  import random
  import typing
  from io import StringIO
  from typing import Optional, Set, Type
  import numpy
  import albumentations
label_desc: Use image node_id 4 for calling a global function with example usage: get_filtered_transforms(base_classes, custom_arguments, except_augmentations) and returns: result