docs: def get(self, setting_name, warn_only_if_overridden=False,
              accept_deprecated='', suppress_warnings=False,
              enforce_type=None, check_if_setting_deprecated=True,
              warning_stacklevel=3):
          """
          Returns a setting value for the setting named by ``setting_name``. The
          returned value is actually a reference to the original setting value,
          so care should be taken to avoid setting the result to a different
          value.
  
          :param setting_name:
              The name of the app setting for which a value is required.
          :type setting_name: str (e.g. "SETTING_NAME")
          :param warn_only_if_overridden:
              If the setting named by ``setting_name`` is deprecated, a value of
              ``True`` can be provided to silence the immediate deprecation
              warning that is otherwise raised by default. Instead, a
              (differently worded) deprecation warning will be raised, but only
              when the setting is overriden.
          :type warn_only_if_overridden: bool
          :param accept_deprecated:
              If the setting named by ``setting_name`` replaces multiple
              deprecated settings, the ``accept_deprecated`` keyword argument can
              be used to specify which of those deprecated settings to accept as
              an override value.
  
              Where the requested setting replaces only a single deprecated
              setting, override values for that deprecated setting will be
              accepted automatically, without having to specify anything.
          :type accept_deprecated: str (e.g. "DEPRECATED_SETTING_NAME")
          :param suppress_warnings:
              Use this to prevent the raising of any deprecation warnings that
              might otherwise be raised. It may be more useful to use
              ``warn_only_if_overridden`` instead.
          :type suppress_warnings: bool
          :param enforce_type:
              When a setting value of a specific type is required, this can be
              used to apply some basic validation at the time of retrieval. If
              supplied, and setting value is found not to be an instance of the
              supplied type, a ``SettingValueTypeInvalid`` error will be raised.
  
              In cases where more than one type of value is accepted, a tuple of
              acceptable types can be provided.
          :type enforce_type: A type (class), or tuple of types
          :param check_if_setting_deprecated:
              Can be used to disable the check that usually happens at the
              beginning of the method to identify whether the setting named by
              ``setting_name`` is deprecated, and conditionally raise a warning.
              This can help to improve efficiency where the same check has
              already been made.
          :type check_if_setting_deprecated: bool
          :param warning_stacklevel:
              When raising deprecation warnings related to the request, this
              value is passed on as ``stacklevel`` to Python's
              ``warnings.warn()`` method, to help give a more accurate indication
              of the code that caused the warning to be raised.
          :type warning_stacklevel: int
          :raises: UnknownSettingNameError, SettingValueTypeInvalid
  
          Instead of calling this method directly, developers are generally
          encouraged to use the direct attribute shortcut, which is a
          syntactically much cleaner way to request values using the default
          options. For example, the the following lines are equivalent::
  
              appsettingshelper.SETTING_NAME
              appsettingshelper.get('SETTING_NAME')
          """
          if check_if_setting_deprecated:
              self._warn_if_deprecated_setting_value_requested(
                  setting_name, warn_only_if_overridden, suppress_warnings,
                  warning_stacklevel)
  
          cache_key = self._make_cache_key(setting_name, accept_deprecated)
          if cache_key in self._raw_cache:
              return self._raw_cache[cache_key]
  
          result = self._get_raw_value(
              setting_name,
              accept_deprecated=accept_deprecated,
              warn_if_overridden=warn_only_if_overridden,
              suppress_warnings=suppress_warnings,
              warning_stacklevel=warning_stacklevel + 1,
          )
  
          if enforce_type and not isinstance(result, enforce_type):
              if isinstance(enforce_type, tuple):
                  msg = (
                      "The value is expected to be one of the following types, "
                      "but a value of type '{current_type}' was found: "
                      "{required_types}."
                  )
                  text_format_kwargs = dict(
                      current_type=type(result).__name__,
                      required_types=enforce_type,
                  )
              else:
                  msg = (
                      "The value is expected to be a '{required_type}', but a "
                      "value of type '{current_type}' was found."
                  )
                  text_format_kwargs = dict(
                      current_type=type(result).__name__,
                      required_type=enforce_type.__name__,
                  )
              self._raise_setting_value_error(
                  setting_name=setting_name,
                  user_value_error_class=OverrideValueTypeInvalid,
                  default_value_error_class=DefaultValueTypeInvalid,
                  additional_text=msg,
                  **text_format_kwargs
              )
          self._raw_cache[cache_key] = result
          return result