code: def autodict_decorate(cls,                         # type: Type[T]
                        include=None,                # type: Union[str, Tuple[str]]
                        exclude=None,                # type: Union[str, Tuple[str]]
                        only_constructor_args=True,  # type: bool
                        only_public_fields=True      # type: bool
                        ):
      # type: (...) -> Type[T]
      
  
      # first check that we do not conflict with other known decorators
      _check_known_decorators(cls, '@autodict')
  
      # perform the class mod
      _execute_autodict_on_class(cls, include=include, exclude=exclude, only_constructor_args=only_constructor_args,
                                 only_public_fields=only_public_fields)
  
      return cls
docs: To automatically generate the appropriate methods so that objects of this class behave like a `dict`,
      manually, without using @autodict decorator.
  
      :param cls: the class on which to execute. Note that it won't be wrapped.
      :param include: a tuple of explicit attribute names to include (None means all)
      :param exclude: a tuple of explicit attribute names to exclude. In such case, include should be None.
      :param only_constructor_args: if True (default), only constructor arguments will be exposed through the dictionary
      view, not any other field that would be created in the constructor or dynamically. This makes it very convenient
      to use in combination with @autoargs. If set to False, the dictionary is a direct view of public object fields.
      :param only_public_fields: this parameter is only used when only_constructor_args is set to False. If
      only_public_fields is set to False, all fields are visible. Otherwise (default), class-private fields will be hidden
      :return: