code: def _render_single_output(
      self, streamlit: st, output_data: BaseModel
  ) -> None:
      try:
          if has_output_ui_renderer(output_data):
              if function_has_named_arg(output_data.render_output_ui, "input"):  # type: ignore
                  # render method also requests the input data
                  output_data.render_output_ui(streamlit, input=self._input_data)  # type: ignore
              else:
                  output_data.render_output_ui(streamlit)  # type: ignore
              return
      except Exception:
          # Use default auto-generation methods if the custom rendering throws an exception
          logger.exception(
              "Failed to execute custom render_output_ui function. Using auto-generation instead"
          )
  
      model_schema = output_data.schema(by_alias=False)
      model_properties = model_schema.get("properties")
      definitions = model_schema.get("definitions")
  
      if model_properties:
          for property_key in output_data.__dict__:
              property_schema = model_properties.get(property_key)
              if not property_schema.get("title"):
                  # Set property key as fallback title
                  property_schema["title"] = property_key
  
              output_property_value = output_data.__dict__[property_key]
  
              if has_output_ui_renderer(output_property_value):
                  output_property_value.render_output_ui(streamlit)  # type: ignore
                  continue
  
              if isinstance(output_property_value, BaseModel):
                  # Render output recursivly
                  streamlit.subheader(property_schema.get("title"))
                  if property_schema.get("description"):
                      streamlit.markdown(
                          property_schema.get("description")
                      )
                  self._render_single_output(
                      streamlit, output_property_value
                  )
                  continue
  
              if property_schema:
                  if schema_utils.is_single_file_property(
                      property_schema
                  ):
                      self._render_single_file_property(
                          streamlit,
                          property_schema,
                          output_property_value,
                      )
                      continue
  
                  if (
                      schema_utils.is_single_string_property(
                          property_schema
                      )
                      or schema_utils.is_single_number_property(
                          property_schema
                      )
                      or schema_utils.is_single_datetime_property(
                          property_schema
                      )
                      or schema_utils.is_single_boolean_property(
                          property_schema
                      )
                  ):
                      self._render_single_text_property(
                          streamlit,
                          property_schema,
                          output_property_value,
                      )
                      continue
                  if (
                      definitions
                      and schema_utils.is_single_enum_property(
                          property_schema, definitions
                      )
                  ):
                      self._render_single_text_property(
                          streamlit,
                          property_schema,
                          output_property_value.value,
                      )
                      continue
  
                  # TODO: render dict as table
  
                  self._render_single_complex_property(
                      streamlit, property_schema, output_property_value
                  )
          return
  
      # Display single field in code block:
      # if len(output_data.__dict__) == 1:
      #     value = next(iter(output_data.__dict__.values()))
  
      #     if type(value) in (int, float, str):
      #         # Should not be a complex object (with __dict__) -> should be a primitive
      #         # hasattr(output_data.__dict__[0], '__dict__')
      #         streamlit.subheader("This is a test:")
      #         streamlit.code(value, language="plain")
      #         return
  
      # Fallback to json output
      streamlit.json(jsonable_encoder(output_data))
  
imports: import datetime
  import inspect
  import mimetypes
  import sys
  from os import getcwd, unlink
  from platform import system
  from tempfile import NamedTemporaryFile
  from typing import Any, Callable, Dict, List, Type
  import pandas
  import streamlit
  from fastapi.encoders import jsonable_encoder
  from loguru import logger
  from pydantic import BaseModel, ValidationError, parse_obj_as
  from opyrator import Opyrator
  from opyrator.core import name_to_title
  from opyrator.ui import schema_utils, streamlit_utils
  from opyrator.ui.streamlit_utils import CUSTOM_STREAMLIT_CSS, SessionState
label_desc: Use image node_id 6 for calling the OutputUI obj's underlying member method code with example usage: obj._render_single_output(streamlit, output_data) without return types