code: def autodict(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
               cls=DECORATED
               ):
      
      return autodict_decorate(cls, include=include, exclude=exclude, only_constructor_args=only_constructor_args,
                               only_public_fields=only_public_fields)
docs: A decorator to makes objects of the class behave like a read-only `dict`. It does several things:
      * it adds collections.Mapping to the list of parent classes (i.e. to the class' `__bases__`)
      * it generates `__len__`, `__iter__` and `__getitem__` in order for the appropriate fields to be exposed in the dict
      view.
      * it adds a static from_dict method to build objects from dicts (only if only_constructor_args=True)
      * it overrides eq method if not already implemented
      * it overrides str and repr method if not already implemented
      
      Parameters allow to customize the list of fields that will be visible.
  
      :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: