code: def propagate_inputs_to_enclave(
      user_code: UserCode, context: ChangeContext
  ):
      # Temporarily disable Oblivious Enclave
      # from ...external.oblv.deployment_client import OblvMetadata
  
      # if isinstance(user_code.enclave_metadata, OblvMetadata):
      #     # relative
      #     oblv_service_class = get_oblv_service()
      #     if isinstance(oblv_service_class, SyftError):
      #         return oblv_service_class
      #     method = context.node.get_service_method(oblv_service_class.get_api_for)
  
      #     api = method(
      #         user_code.enclave_metadata,
      #         context.node.signing_key,
      #         worker_name=context.node.name,
      #     )
      #     send_method = api.services.oblv.send_user_code_inputs_to_enclave
  
      if isinstance(user_code.enclave_metadata, EnclaveMetadata):
          # TODO 🟣 Restructure url it work for local mode host.docker.internal
  
          connection = route_to_connection(
              user_code.enclave_metadata.route
          )
          enclave_client = EnclaveClient(
              connection=connection,
              credentials=context.node.signing_key,
          )
  
          send_method = (
              enclave_client.api.services.enclave.send_user_code_inputs_to_enclave
          )
  
      else:
          return SyftSuccess(
              message="Current Request does not require Enclave Transfer"
          )
  
      inputs = user_code.input_policy._inputs_for_context(context)
      if isinstance(inputs, SyftError):
          return inputs
  
      # Save inputs to blob store
      for var_name, var_value in inputs.items():
          if isinstance(var_value, (ActionObject, TwinObject)):
              # Set the obj location to enclave
              var_value._set_obj_location_(
                  enclave_client.api.node_uid,
                  enclave_client.verify_key,
              )
              var_value._save_to_blob_storage()
  
              inputs[var_name] = var_value
  
      # send data of the current node to enclave
      res = send_method(
          user_code_id=user_code.id,
          inputs=inputs,
          node_name=context.node.name,
          node_id=context.node.id,
      )
      return res
  
imports: from typing import Dict
  from typing import Union
  from ...client.enclave_client import EnclaveClient
  from ...client.enclave_client import EnclaveMetadata
  from ...serde.serializable import serializable
  from ...service.response import SyftError
  from ...service.response import SyftSuccess
  from ...service.user.user_roles import GUEST_ROLE_LEVEL
  from ...store.document_store import DocumentStore
  from ...types.twin_object import TwinObject
  from ...types.uid import UID
  from ..action.action_object import ActionObject
  from ..code.user_code_service import UserCode
  from ..code.user_code_service import UserCodeStatus
  from ..context import AuthedServiceContext
  from ..context import ChangeContext
  from ..network.routes import route_to_connection
  from ..service import AbstractService
  from ..service import service_method
label_desc: Use image node_id 2 for calling a global function with example usage: propagate_inputs_to_enclave(user_code, context) and returns: res, SyftSuccess, inputs