code: def autoprops_decorate(cls,           # type: Type[T]
                         include=None,  # type: Union[str, Tuple[str]]
                         exclude=None   # type: Union[str, Tuple[str]]
                         ):
      # type: (...) -> Type[T]
      
  
      # first check that we do not conflict with other known decorators
      _check_known_decorators(cls, '@autoprops')
  
      # perform the class mod
      _execute_autoprops_on_class(cls, include=include, exclude=exclude)
  
      # TODO better create a wrapper than modify the class? Probably not
      # class Autoprops_Wrapper(object):
      #     def __init__(self, *args, **kwargs):
      #         self.wrapped = cls(*args, **kwargs)
      #
      # return Autoprops_Wrapper
  
      return cls
docs: To automatically generate all properties getters and setters from the class constructor manually, without using
      @autoprops decorator.
      * if a @contract annotation exist on the __init__ method, mentioning a contract for a given parameter, the
      parameter contract will be added on the generated setter method
      * The user may override the generated getter and/or setter by creating them explicitly in the class and annotating
      them with @getter_override or @setter_override. Note that the contract will still be dynamically added on the
      setter, even if the setter already has one (in such case a `UserWarning` will be issued)
  
      :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.
      :return: