code: def __calculate(self, item):
      self.__order[item] = self.__n_calculated
      self.__n_calculated += 1
  
      value, has = self.__get_value(item)
  
      if has:
          pass
      elif item not in self.__types:
          raise AttributeError(
              f"{self.__class__.__name__} has no attribute `{item}`"
          )
      elif (
          type(self.__types[item]) == type
          and self.__types[item] not in _STANDARD_TYPES
      ):
          config_function = ConfigFunction(
              self.__types[item],
              config_names=self.__config_items[item],
              option_name="from_type",
          )
  
          self.__options[item] = OrderedDict()
          self.__options[item]["from_type"] = config_function
          self.__defaults[item] = "from_type"
          value = "from_type"
      else:
          raise AttributeError(
              f"{self.__class__.__name__} cannot calculate config `{item}`"
          )
  
      if item in self.__options and value in self.__options[item]:
          func = self.__options[item][value]
          name = ".".join(self.__ancestry + [item])
  
          with monit.section(f"Prepare {name}", is_not_in_loop=True):
              calc_value = func(self)
  
          if (
              isinstance(func.config_names, list)
              and len(func.config_names) > 1
          ):
              if not isinstance(calc_value, list) and not isinstance(
                  calc_value, tuple
              ):
                  raise RuntimeError(
                      f"Option {value} for {func.config_names} should return a list or tuple"
                  )
              if len(calc_value) != len(func.config_names):
                  raise RuntimeError(
                      f"Option {value} for {func.config_names} should return a list or tuple"
                  )
  
              for i in range(len(calc_value)):
                  self.__set_calculated_value(
                      func.config_names[i], calc_value[i]
                  )
          else:
              self.__set_calculated_value(item, calc_value)
      else:
          self.__set_calculated_value(item, value)
  
imports: import types
  import warnings
  from collections import OrderedDict
  from typing import Dict, List, Callable, Union, Tuple, Optional, Type, Set, Iterable, Any
  from .config_function import ConfigFunction
  from .config_item import ConfigItem
  from .eval_function import EvalFunction
  from .utils import Value
  from ...None import monit
label_desc: Use image node_id 12 for calling the Configs obj's underlying member method code with example usage: obj.__calculate(item) without return types