code: def handle_message(message: bytes, syft_worker_id: UID):
      # relative
      from ...node.node import Node
  
      queue_item = deserialize(message, from_bytes=True)
      worker_settings = queue_item.worker_settings
  
      queue_config = worker_settings.queue_config
      queue_config.client_config.create_producer = False
      queue_config.client_config.n_consumers = 0
  
      worker = Node(
          id=worker_settings.id,
          name=worker_settings.name,
          signing_key=worker_settings.signing_key,
          document_store_config=worker_settings.document_store_config,
          action_store_config=worker_settings.action_store_config,
          blob_storage_config=worker_settings.blob_store_config,
          queue_config=queue_config,
          is_subprocess=True,
          migrate=False,
      )
  
      # otherwise it reads it from env, resulting in the wrong credentials
      worker.id = worker_settings.id
      worker.signing_key = worker_settings.signing_key
  
      credentials = queue_item.syft_client_verify_key
  
      res = evaluate_can_run_job(
          queue_item.job_id, worker.job_stash, credentials
      )
      if res.is_err():
          raise Exception(res.value)
      job_item: Job = res.ok()
  
      queue_item.status = Status.PROCESSING
      queue_item.node_uid = worker.id
  
      job_item.status = JobStatus.PROCESSING
      job_item.node_uid = worker.id
      job_item.updated_at = DateTime.now()
  
      # try:
      #     worker_name = os.getenv("DOCKER_WORKER_NAME", None)
      #     docker_worker = worker.worker_stash.get_worker_by_name(
      #         credentials, worker_name
      #     ).ok()
      #     job_item.job_worker_id = str(docker_worker.container_id)
      # except Exception:
      #     job_item.job_worker_id = str(worker.id)
      if syft_worker_id is not None:
          job_item.job_worker_id = syft_worker_id
  
      queue_result = worker.queue_stash.set_result(
          credentials, queue_item
      )
      if isinstance(queue_result, SyftError):
          raise Exception(message=f"{queue_result.err()}")
  
      job_result = worker.job_stash.set_result(credentials, job_item)
      if isinstance(job_result, SyftError):
          raise Exception(message=f"{job_result.err()}")
  
      if queue_config.thread_workers:
          # stdlib
          from threading import Thread
  
          p = Thread(
              target=handle_message_multiprocessing,
              args=(worker_settings, queue_item, credentials),
          )
          p.start()
      else:
          p = multiprocessing.Process(
              target=handle_message_multiprocessing,
              args=(worker_settings, queue_item, credentials),
          )
          p.start()
  
          job_item.job_pid = p.pid
          worker.job_stash.set_result(credentials, job_item)
  
      p.join()
  
imports: import multiprocessing
  import threading
  import time
  from typing import Any
  from typing import Optional
  from typing import Type
  from typing import Union
  import psutil
  from result import Err
  from result import Ok
  from result import Result
  from ...node.credentials import SyftVerifyKey
  from ...serde.deserialize import _deserialize
  from ...serde.serializable import serializable
  from ...service.context import AuthedServiceContext
  from ...types.datetime import DateTime
  from ...types.uid import UID
  from ..job.job_stash import Job
  from ..job.job_stash import JobStash
  from ..job.job_stash import JobStatus
  from ..response import SyftError
  from ..response import SyftSuccess
  from ..worker.worker_stash import WorkerStash
  from .base_queue import AbstractMessageHandler
  from .base_queue import BaseQueueManager
  from .base_queue import QueueConfig
  from .base_queue import QueueConsumer
  from .base_queue import QueueProducer
  from .queue_stash import QueueItem
  from .queue_stash import Status
label_desc: Use image node_id 1 for calling the APICallMessageHandler obj's underlying member method code with example usage: obj.handle_message(message, syft_worker_id) without return types