code: def _call_signature(
      schema,
      include_inputs=True,
      include_kwargs=True,
      include_self=False,
      data_node_return=True,
      all_args_optional=False,
      input_annotation_gen=_get_annotation_input_regular,
      return_annotation_gen=_get_annotation_return_regular,
      filter_annotations=False,
  ) -> Signature:
      """Generate a Signature for given schema.
  
      Parameters
      ----------
      schema : OpSchema
          Schema for the operator.
      include_inputs : bool, optional
          If positional inputs should be included in the signature, by default True
      include_kwargs : bool, optional
          If keyword arguments should be included in the signature, by default True
      include_self : bool, optional
          Prepend `self` as first positional argument in the signature, by default False
      data_node_return : bool, optional
          If the signature should have a return annotation or return None (for ops class __init__),
          by default True
      all_args_optional : bool, optional
          Make all keyword arguments optional, even if they are not - needed by the ops API, where
          the argument can be specified in either __init__ or __call__, by default False
      input_annotation_gen : Callable[[OpSchema], type annotation]
          Callback generating the annotation to be used for type annotation of inputs.
      return_annotation_gen : Callable[[OpSchema], type annotation]
          Callback generating the return type annotation for given schema
      """
      param_list = []
      if include_self:
          param_list.append(
              Parameter("self", kind=Parameter.POSITIONAL_ONLY)
          )
  
      if include_inputs:
          param_list.extend(
              _get_positional_input_params(
                  schema, input_annotation_gen=input_annotation_gen
              )
          )
  
      if include_kwargs:
          param_list.extend(
              _get_keyword_params(
                  schema, all_args_optional=all_args_optional
              )
          )
          param_list.extend(
              _get_implicit_keyword_params(
                  schema, all_args_optional=all_args_optional
              )
          )
  
      if data_node_return:
          return_annotation = return_annotation_gen(schema)
      else:
          return_annotation = None
      if filter_annotations:
          param_list = [
              Parameter(name=p.name, kind=p.kind, default=p.default)
              for p in param_list
          ]
          return_annotation = Signature.empty
      return Signature(param_list, return_annotation=return_annotation)
  
imports: from inspect import Parameter, Signature
  import ast
  import os
  from pathlib import Path
  from contextlib import closing
  from typing import Union, Optional
  from typing import Sequence, List, Any
  from nvidia.dali import backend
  from nvidia.dali import types
  from nvidia.dali.ops import _registry, _names, _docs
  from nvidia.dali import types
  from nvidia.dali import ops, fn
label_desc: Use image node_id 12 for calling a global function with example usage: _call_signature(schema, include_inputs, include_kwargs, include_data_node_return, all_args_optional, input_annotation_gen, return_annotation_gen, filter_annotations) and returns: Signature