original_docstring: 
      Decorator to create a signature-preserving wrapper function.
  
      It is similar to `functools.wraps`, but relies on a proper dynamically-generated function. Therefore as opposed to
      `functools.wraps`, the wrapper body will not be executed if the arguments provided are not
      compliant with the signature - instead a `TypeError` will be raised before entering the wrapper body.
  
      `@wraps(f)` is equivalent to
  
          `@with_signature(signature(f),
                           func_name=f.__name__,
                           doc=f.__doc__,
                           module_name=f.__module__,
                           qualname=f.__qualname__,
                           __wrapped__=f,
                           **f.__dict__,
                           **attrs)`
  
      In other words, as opposed to `@with_signature`, the metadata (doc, module name, etc.) is provided by the wrapped
      `f`, so that the created function seems to be identical (except for the signature if a non-None `new_sig` is
      provided). If `new_sig` is None, we set the additional `__wrapped__` attribute on the created function, to stay
      compliant with the `functools.wraps` convention.
      See https://docs.python.org/3/library/functools.html#functools.wraps
      
docstring: Decorator to create a signature-preserving wrapper function.
  It is similar to `functools.wraps`, but relies on a proper dynamically-generated function. Therefore as opposed to
  `functools.wraps`, the wrapper body will not be executed if the arguments provided are not
  compliant with the signature - instead a `TypeError` will be raised before entering the wrapper body.
  
  
  
  
  
  
docstring_tokens: Decorator to create a signature - preserving wrapper function . It is similar to ` functools . wraps ` but relies on a proper dynamically - generated function . Therefore as opposed to ` functools . wraps ` the wrapper body will not be executed if the arguments provided are not compliant with the signature - instead a ` TypeError ` will be raised before entering the wrapper body .
code: def wraps(f,
            new_sig=None,         # type: Union[str, Signature]
            func_name=None,             # type: str
            inject_as_first_arg=False,  # type: bool
            add_source=True,   # type: bool
            add_impl=True,  # type: bool
            doc=None,         # type: str
            qualname=None,    # type: str
            module_name=None,  # type: str
            **attrs
            ):
      """
      Decorator to create a signature-preserving wrapper function.
  
      It is similar to `functools.wraps`, but relies on a proper dynamically-generated function. Therefore as opposed to
      `functools.wraps`, the wrapper body will not be executed if the arguments provided are not
      compliant with the signature - instead a `TypeError` will be raised before entering the wrapper body.
  
      `@wraps(f)` is equivalent to
  
          `@with_signature(signature(f),
                           func_name=f.__name__,
                           doc=f.__doc__,
                           module_name=f.__module__,
                           qualname=f.__qualname__,
                           __wrapped__=f,
                           **f.__dict__,
                           **attrs)`
  
      In other words, as opposed to `@with_signature`, the metadata (doc, module name, etc.) is provided by the wrapped
      `f`, so that the created function seems to be identical (except for the signature if a non-None `new_sig` is
      provided). If `new_sig` is None, we set the additional `__wrapped__` attribute on the created function, to stay
      compliant with the `functools.wraps` convention.
      See https://docs.python.org/3/library/functools.html#functools.wraps
      """
      func_name, func_sig, doc, qualname, module_name, all_attrs = _get_args_for_wrapping(f, new_sig, func_name, doc,
                                                                                          qualname, module_name, attrs)
  
      return with_signature(func_sig,
                            func_name=func_name,
                            inject_as_first_arg=inject_as_first_arg,
                            add_source=add_source, add_impl=add_impl,
                            doc=doc,
                            qualname=qualname,
                            module_name=module_name,
                            **all_attrs)
code_tokens: def wraps ( f , new_sig = None , func_name = None , inject_as_first_arg = False , add_source = True , add_impl = True , doc = None , qualname = None , module_name = None , ** attrs ) : func_name , func_sig , doc , qualname , module_name , all_attrs = _get_args_for_wrapping ( f , new_sig , func_name , doc , qualname , module_name , attrs ) return with_signature ( func_sig , func_name = func_name , inject_as_first_arg = inject_as_first_arg , add_source = add_source , add_impl = add_impl , doc = doc , qualname = qualname , module_name = module_name , ** all_attrs )
short_docstring: Decorator to create a signature-preserving wrapper function.
short_docstring_tokens: Decorator to create a signature - preserving wrapper function .
comment: # type: Union[str, Signature]$SEP$# type: str$SEP$# type: bool$SEP$# type: bool$SEP$# type: bool$SEP$# type: str$SEP$# type: str$SEP$# type: str$SEP$"""
      Decorator to create a signature-preserving wrapper function.
  
      It is similar to `functools.wraps`, but relies on a proper dynamically-generated function. Therefore as opposed to
      `functools.wraps`, the wrapper body will not be executed if the arguments provided are not
      compliant with the signature - instead a `TypeError` will be raised before entering the wrapper body.
  
      `@wraps(f)` is equivalent to
  
          `@with_signature(signature(f),
                           func_name=f.__name__,
                           doc=f.__doc__,
                           module_name=f.__module__,
                           qualname=f.__qualname__,
                           __wrapped__=f,
                           **f.__dict__,
                           **attrs)`
  
      In other words, as opposed to `@with_signature`, the metadata (doc, module name, etc.) is provided by the wrapped
      `f`, so that the created function seems to be identical (except for the signature if a non-None `new_sig` is
      provided). If `new_sig` is None, we set the additional `__wrapped__` attribute on the created function, to stay
      compliant with the `functools.wraps` convention.
      See https://docs.python.org/3/library/functools.html#functools.wraps
      """