Make docstrings more consistent using format-webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/common/system/logutils.py

 # Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 # 1.  Redistributions of source code must retain the above copyright
 #     notice, this list of conditions and the following disclaimer.
 # 2.  Redistributions in binary form must reproduce the above copyright
 #     notice, this list of conditions and the following disclaimer in the
 #     documentation and/or other materials provided with the distribution.
@@ skipping 29 matching lines @@
 
 _webkitpy_dir = ""
 """The normalized, absolute path to the ...Scripts/webkitpy directory."""
 
 
 def _normalize_path(path):
     """Return the given path normalized.
 
     Converts a path to an absolute path, removes any trailing slashes,
     removes any extension, and lower-cases it.
-
     """
     path = os.path.abspath(path)
     path = os.path.normpath(path)
     path = os.path.splitext(path)[0]  # Remove the extension, if any.
     path = path.lower()
 
     return path
 
 
 # Observe that the implementation of this function does not require
@@ skipping 18 matching lines @@
 
     Args:
       path: The path of the module.  Normally, this parameter should be
             the __file__ variable of the module.
 
     Sample usage:
 
       from webkitpy.common.system import logutils
 
       _log = logutils.get_logger(__file__)
-
     """
     # Since we assign to _scripts_dir and _webkitpy_dir in this function,
     # we need to declare them global.
     global _scripts_dir
     global _webkitpy_dir
 
     path = _normalize_path(path)
 
     # Lazily evaluate _webkitpy_dir and _scripts_dir.
     if not _scripts_dir:
@@ skipping 23 matching lines @@
         logger_name = os.path.splitext(basename)[0]
 
     return logging.getLogger(logger_name)
 
 
 def _default_handlers(stream, logging_level):
     """Return a list of the default logging handlers to use.
 
     Args:
       stream: See the configure_logging() docstring.
-
     """
     # Create the filter.
     def should_log(record):
         """Return whether a logging.LogRecord should be logged."""
         if record.name.startswith("webkitpy.thirdparty"):
             return False
         return True
 
     logging_filter = logging.Filter()
     logging_filter.filter = should_log
@@ skipping 27 matching lines @@
                      logging.INFO.
       logger: A logging.logger instance to configure.  This parameter
               should be used only in unit tests.  Defaults to the
               root logger.
       stream: A file-like object to which to log used in creating the default
               handlers.  The stream must define an "encoding" data attribute,
               or else logging raises an error.  Defaults to sys.stderr.
       handlers: A list of logging.Handler instances to add to the logger
                 being configured.  If this parameter is provided, then the
                 stream parameter is not used.
-
     """
     # If the stream does not define an "encoding" data attribute, the
     # logging module can throw an error like the following:
     #
     # Traceback (most recent call last):
     #   File "/System/Library/Frameworks/Python.framework/Versions/2.6/...
     #         lib/python2.6/logging/__init__.py", line 761, in emit
     #     self.stream.write(fs % msg.encode(self.stream.encoding))
     # LookupError: unknown encoding: unknown
     if logging_level is None:
         logging_level = logging.INFO
     if logger is None:
         logger = logging.getLogger()
     if stream is None:
         stream = sys.stderr
     if handlers is None:
         handlers = _default_handlers(stream, logging_level)
 
     logger.setLevel(logging_level)
 
     for handler in handlers:
         logger.addHandler(handler)
 
     _log.debug("Debug logging enabled.")
 
     return handlers