code: def _load_ops():
      _registry._discover_ops()
      _all_ops = _registry._all_registered_ops()
      ops_module = sys.modules[__name__]
  
      for op_reg_name in _all_ops:
          # TODO(klecki): Make this a function: _add_op(op_reg_name) and invoke it immediately
          # with register_xxx_op(). Now it relies on those class being present in this module
          # at the time of registration.
          schema = _b.TryGetSchema(op_reg_name)
          make_hidden = schema.IsDocHidden() if schema else False
          _, submodule, op_name = _process_op_name(
              op_reg_name, make_hidden
          )
          module = _internal.get_submodule(ops_module, submodule)
          if not hasattr(module, op_name):
              op_class = python_op_factory(op_name, op_reg_name)
              _internal._adjust_operator_module(
                  op_class, ops_module, submodule
              )
              setattr(module, op_name, op_class)
  
              if op_name not in ["ExternalSource"]:
                  _wrap_op(op_class, submodule)
  
              # The operator was inserted into nvidia.dali.ops.hidden module, let's import it here
              # so it would be usable, but not documented as coming from other module
              if make_hidden:
                  parent_module = _internal.get_submodule(
                      ops_module, submodule[:-1]
                  )
                  setattr(parent_module, op_name, op_class)
  
imports: import sys
  import threading
  import tree
  import warnings
  from itertools import count
  import nvidia.dali.python_function_plugin
  from nvidia.dali import backend
  from nvidia.dali import fn
  from nvidia.dali import internal
  from nvidia.dali.data_node import DataNode
  from nvidia.dali.pipeline import Pipeline
  from nvidia.dali.types import _type_name_convert_to_string, _type_convert_value, _default_converter, _vector_element_type, ScalarConstant, Constant
  from nvidia.dali import _conditionals
  from nvidia.dali.ops import _registry, _names, _docs, _operator_utils
  from nvidia.dali.ops._registry import cpu_ops, mixed_ops, gpu_ops, register_cpu_op, register_gpu_op
  from nvidia.dali.ops._names import _op_name, _process_op_name, _schema_name
  from nvidia.dali.ops._operator_utils import _build_input_sets, _repack_output_sets
  from nvidia.dali.external_source import ExternalSource
  from nvidia.dali.ops._operators.python_function import PythonFunctionBase, PythonFunction, DLTensorPythonFunction, _dlpack_to_array, _dlpack_from_array
  from nvidia.dali.ops._operators.compose import Compose
  from nvidia.dali.ops._operators.math import _arithm_op, _group_inputs, _generate_input_desc
label_desc: Use image node_id 14 for calling a global function with example usage: _load_ops() without return types