reformat with black;

use pwm_min of 1 since newer kernels have different behaviour on pwm=0

config-example.yaml

@@ -6,16 +6,26 @@
 # otherwise INFO is a good value.
 loglevel: DEBUG
 
-# Set interval (seconds) in which PyFan is checking your temp sources and adjusts PWM values.
+# Frequency in seconds of feeding sensors values into PID. Higher frequency (lower value) means PID can react faster.
-interval: 1
+# Fans only get set every thermalzones->interval seconds, regardless of this value.
+# Must be lower then your lowest thermalzone interval.
+pid_interval: 0.2
 
 thermalzones:
   - name: GPU+SYSTEM
-    # This is your source temperature.
+
+    # This is your source temperature. You can add multiple sources, see thermal zone below for an example.
     source: amdgpu/temp1_input
+
     # This is most likely 1000 for your temp sensor as well.
-    # If not, check what you sensor is outputing if you try to read from it.
+    # If not, check what you sensor is outputting if you try to read from it.
     factor: 1000
+
+    # Frequency in which fan speed should be adjusted in seconds.
+    # PyFan reads sensors values from hwmon every pid_interval, but only sets fan speeds in this interval.
+    # Can't be lower then pid_interval.
+    interval: 3
+
     # Define all fans that this thermal zone is going to control.
     # There is no limit to how many fans one thermal zone can control.
     # You can have different limitations on your fans, for example:
@@ -27,24 +37,29 @@ thermalzones:
     fan:
       - it8686/pwm2
       - amdgpu/pwm1: 170
+
     # This is your target temperature. This is one of the main control knobs. Set this to a comfortable temperature for
     # your equipment. Don't set this as high as its max temperature allowance, since pid is gonna allow some overshooting.
     target: 60
-    # For understanding PID please have a look at https://en.wikipedia.org/wiki/PID_controller. The forementioned page
+
+    # For understanding PID please have a look at https://en.wikipedia.org/wiki/PID_controller. The aforementioned page
     # also explains what p, i and d stand for and what they do in detail. These are the second main control knobs.
-    # Simplified you can view them as:
+    # Simplified you can view them as weights for:
-    #   p = how heavy should pid weight difference in temperature
+    #   p = difference in temperature (momentarily)
-    #   i = how heavy should pid weight difference in temperature over time
+    #   i = difference in temperature over time
-    #   d = how heavy should pid weight rate of chance in temperature
+    #   d = rate of chance in temperature
     pid:
       p: 1
       i: 1
       d: 1.5
   - name: CPU
-    source: coretemp/temp1_input
+    source:
+      - coretemp/temp1_input
+      - amdgpu/temp1_input
     factor: 1000
+    interval: 3
     fan:
-      - it8686/pwm1: [100, 200]
+      - it8686/pwm1: [ 100, 200 ]
     target: 50
     pid:
       p: 1

pyfan.py

@@ -15,24 +15,42 @@ class ThermalZone:
     def __init__(self, config, pyfan_parent) -> None:
         self.fans = config["fan"]
         self.temp_source = config["source"]
-        self.pid = PID(config["pid"]["p"], config["pid"]["i"], config["pid"]["d"], setpoint=0)
-        self.pid.output_limits = (0, 255)
         self.factor = 1 / config["factor"]
         self.name = config["name"]
         self.target = config["target"]
-        self.hwmap = pyfan_parent.hwmap
         self.pyfan = pyfan_parent
-        self.alias_replace = re.compile('|'.join(self.hwmap.keys()))
+        self.hwmap = self.pyfan.hwmap
+        self.alias_replace = re.compile("|".join(self.hwmap.keys()))
+
+        if "interval" not in config:
+            config["interval"] = 3
+            logging.getLogger("pyfan").warning(
+                "[%s] No interval specified, using default. This is deprecated since 1.6 and may be removed in future "
+                "versions. See example config for reference.",
+                self.name,
+            )
+
+        self.pid = PID(
+            config["pid"]["p"],
+            config["pid"]["i"],
+            config["pid"]["d"],
+            setpoint=0,
+            sample_time=config["interval"],
+        )
+
+        # we prefer 3 for pwm_enable, but since some chips do not support this mode, use 1 with pwm_min of 1 as fallback
+        # more on pwm=0 behaviour: https://www.kernel.org/doc/html/latest/hwmon/pwm-fan.html
+        self.pid.output_limits = (1, 255)
         self.setup_pwm()
 
         logging.getLogger("pyfan").info(
-            "[{zone}] Source={source} Fans={fans} Factor={factor} PID={pid}".format(zone=self.name,
+            "[%s] Source=%s Fans=%s Factor=%f %s",
-                                                                                    source=self.temp_source,
+            self.name,
-                                                                                    fans=self.fans,
+            self.temp_source,
-                                                                                    factor=self.factor,
+            self.fans,
-                                                                                    pid=(
+            self.factor,
-                                                                                        self.pid.Kp, self.pid.Ki,
+            self.pid,
-                                                                                        self.pid.Kd)))
+        )
 
     def eval(self):
         if self.get_temp():
@@ -41,42 +59,67 @@ class ThermalZone:
 
             try:
                 for target_fan in self.fans:
-                    if type(target_fan) is dict:
+                    if isinstance(target_fan, dict):
                         fan = list(target_fan.keys())[0]
                         fan_val = list(target_fan.values())[0]
 
-                        if type(fan_val) is list:
+                        if isinstance(fan_val, list):
                             if len(fan_val) < 2:
                                 logging.getLogger("pyfan").warning(
-                                    "[%s] max/min for %s was not set correctly (%s)" % (self.name, fan, fan_val))
+                                    "[%s] max/min for %s was not set correctly (%s)",
+                                    self.name,
+                                    fan,
+                                    fan_val,
+                                )
 
-                            self.write_sysfs(fan, min(fan_val[1], max(val, fan_val[0])))
+                            if self.read_sysfs(fan) != min(
-                        else:
+                                fan_val[1], max(val, fan_val[0])
+                            ):
+                                self.write_sysfs(
+                                    fan, min(fan_val[1], max(val, fan_val[0]))
+                                )
+                        elif self.read_sysfs(fan) != min(val, fan_val):
                             self.write_sysfs(fan, min(val, fan_val))
 
                         logging.getLogger("pyfan").debug(
-                            "[{name}] {fan} is set at {val}%".format(name=self.name, fan=fan,
+                            "[%s] %s=%i%%",
-                                                                     val=int(int(self.read_sysfs(fan)) / 255 * 100)))
+                            self.name,
-                    else:
+                            fan,
+                            int(int(self.read_sysfs(fan)) / 255 * 100),
+                        )
+                    elif self.read_sysfs(target_fan) != val:
                         self.write_sysfs(target_fan, val)
             except OSError as err:
                 logging.getLogger("pyfan").warning(
-                    "[%s] Failed to set pwm, trying to reset it. (%s)" % (self.name, err.strerror))
+                    "[%s] Failed to set pwm, trying to reset it. (%s)",
+                    self.name,
+                    err.strerror,
+                )
+
                 self.setup_pwm(1)
 
-            p, i, d = self.pid.components
-
             logging.getLogger("pyfan").debug(
-                "[{name}] {val}% ({diff}C/{temp}C) ({p}|{i}|{d})".format(name=self.name, val=int(val / 255 * 100),
+                "[%s] %i%% D:%iC T:%iC %s",
-                                                                         diff=diff,
+                self.name,
-                                                                         temp=self.get_temp(), p=int(p), i=int(i),
+                int(val / 255 * 100),
-                                                                         d=int(d)))
+                diff,
+                self.get_temp(),
+                self.pid,
+            )
 
     def get_temp(self):
-        if self.read_sysfs(self.temp_source):
+        if isinstance(self.temp_source, list):
-            return float(self.read_sysfs(self.temp_source)) * self.factor
+            max_temp = -1.0
+            for fan in self.temp_source:
+                if self.read_sysfs(fan):
+                    max_temp = max(float(self.read_sysfs(fan)) * self.factor, max_temp)
+
+            return max_temp
         else:
-            return None
+            if self.read_sysfs(self.temp_source):
+                return float(self.read_sysfs(self.temp_source)) * self.factor
+            else:
+                return None
 
     def restore(self):
         self.setup_pwm(2)
@@ -84,25 +127,26 @@ class ThermalZone:
     def setup_pwm(self, value=1):
         for target_fan in self.fans:
             try:
-                if type(target_fan) is dict:
+                if isinstance(target_fan, dict):
                     self.set_pwm_mode(list(target_fan.keys())[0], value)
                 else:
                     self.set_pwm_mode(target_fan, value)
-            except FileNotFoundError as err:
+            except FileNotFoundError:
-                logging.getLogger("pyfan").warning("[%s] pwm not found."
+                logging.getLogger("pyfan").warning(
-                                                   " Try reloading hwmon map..." % self.name)
+                    "[%s] pwm not found. Try reloading hwmon map...", self.name
+                )
                 self.hwmap = self.pyfan.hwmap
 
     def replace_alias(self, path):
         replaced = self.alias_replace.sub(lambda x: self.hwmap[x.group()], path)
-        logging.getLogger("pyfan").debug("[ALIAS] %s -> %s" % (path, replaced))
+        logging.getLogger("pyfan").debug("[ALIAS] %s -> %s", path, replaced)
         return replaced
 
     def build_pwm_path(self, specific):
         return self.replace_alias(SYSFS_HWMON_BASE + specific)
 
     def write_sysfs(self, path, value):
-        with open(self.build_pwm_path(path), 'w') as sysfs_f:
+        with open(self.build_pwm_path(path), "w") as sysfs_f:
             sysfs_f.write(str(value))
 
     def read_sysfs(self, path):
@@ -111,8 +155,10 @@ class ThermalZone:
                 return sysfs_f.readline()
         except FileNotFoundError as err:
             logging.getLogger("pyfan").warning(
-                "[%s] temp source not found. Not ready yet or wrong path? (%s)" % (self.name,
+                "[%s] temp source not found. Not ready yet or wrong path? (%s)",
-                                                                                   err.strerror))
+                self.name,
+                err.strerror,
+            )
             return None
 
     def set_pwm_mode(self, path, value=1):
@@ -124,18 +170,21 @@ class PyFan:
         self.config = self.__load_config(config)
         logging.basicConfig(level=logging.getLevelName(self.config["loglevel"]))
         self.zones = []
-        self._hwmon_map = {}
+        if "pid_interval" not in self.config:
-
+            self.interval = 0.2
-        if "interval" in self.config:
+            logging.getLogger("pyfan").warning(
-            self.interval = self.config["interval"]
+                "No pid_interval specified, using default. This is deprecated since 1.6 and may be removed in future "
+                "versions. See example config for reference."
+            )
         else:
-            self.interval = 1
+            self.interval = self.config["pid_interval"]
 
         for zone in self.config["thermalzones"]:
             self.zones.append(ThermalZone(zone, self))
 
         logging.getLogger("pyfan").info(
-            "Finished creating %d thermal zones, checking all %d seconds" % (len(self.zones), self.interval))
+            "Created %d thermal zones, pid_interval=%f.", len(self.zones), self.interval
+        )
 
     def __enter__(self):
         return self
@@ -150,16 +199,16 @@ class PyFan:
 
     @property
     def hwmap(self):
-        self._hwmon_map.clear()
+        hwmon_map = {}
 
         names = glob.glob(SYSFS_HWMON_BASE + "hwmon*/name")
 
         for name in names:
             hwmon = name.split("/")[-2]
             with open(name) as file:
-                hwname = file.read().strip()
+                hw_name = file.read().strip()
-            self._hwmon_map[hwname] = hwmon
+            hwmon_map[hw_name] = hwmon
-        return self._hwmon_map
+        return hwmon_map
 
     @staticmethod
     def __load_config(path):

pyfan.pyi

@@ -0,0 +1,54 @@
+from typing import Any, Pattern
+
+from simple_pid import PID
+
+SYSFS_HWMON_BASE: str
+
+
+class ThermalZone:
+    fans: Any = ...
+    temp_source: Any = ...
+    pid: PID = ...
+    factor: float = ...
+    name: str = ...
+    target: Any = ...
+    hwmap: dict = ...
+    pyfan: PyFan = ...
+    alias_replace: Pattern = ...
+
+    def __init__(self, config: dict, pyfan_parent: PyFan) -> None: ...
+
+    def eval(self) -> None: ...
+
+    def get_temp(self): ...
+
+    def restore(self) -> None: ...
+
+    def setup_pwm(self, value: int = ...) -> None: ...
+
+    def replace_alias(self, path: str): ...
+
+    def build_pwm_path(self, specific: Any): ...
+
+    def write_sysfs(self, path: str, value: Any) -> None: ...
+
+    def read_sysfs(self, path: str): ...
+
+    def set_pwm_mode(self, path: str, value: int = ...) -> None: ...
+
+
+class PyFan:
+    config: dict = ...
+    zones: list = ...
+    interval: float = ...
+
+    def __init__(self, config: str = ...) -> None: ...
+
+    def __enter__(self): ...
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None: ...
+
+    def eval(self) -> None: ...
+
+    @property
+    def hwmap(self): ...

pylintrc

@@ -0,0 +1,441 @@
+# This Pylint rcfile contains a best-effort configuration to uphold the
+# best-practices and style described in the Google Python style guide:
+#   https://google.github.io/styleguide/pyguide.html
+#
+# Its canonical open-source location is:
+#   https://google.github.io/styleguide/pylintrc
+
+[MASTER]
+
+# Files or directories to be skipped. They should be base names, not paths.
+ignore=third_party
+
+# Files or directories matching the regex patterns are skipped. The regex
+# matches against base names, not paths.
+ignore-patterns=
+
+# Pickle collected data for later comparisons.
+persistent=no
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Use multiple processes to speed up Pylint.
+jobs=4
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
+confidence=
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+#enable=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once).You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use"--disable=all --enable=classes
+# --disable=W"
+disable=abstract-method,
+        apply-builtin,
+        arguments-differ,
+        attribute-defined-outside-init,
+        backtick,
+        bad-option-value,
+        basestring-builtin,
+        buffer-builtin,
+        c-extension-no-member,
+        consider-using-enumerate,
+        cmp-builtin,
+        cmp-method,
+        coerce-builtin,
+        coerce-method,
+        delslice-method,
+        div-method,
+        duplicate-code,
+        eq-without-hash,
+        execfile-builtin,
+        file-builtin,
+        filter-builtin-not-iterating,
+        fixme,
+        getslice-method,
+        global-statement,
+        hex-method,
+        idiv-method,
+        implicit-str-concat-in-sequence,
+        import-error,
+        import-self,
+        import-star-module-level,
+        inconsistent-return-statements,
+        input-builtin,
+        intern-builtin,
+        invalid-str-codec,
+        locally-disabled,
+        long-builtin,
+        long-suffix,
+        map-builtin-not-iterating,
+        misplaced-comparison-constant,
+        missing-function-docstring,
+        metaclass-assignment,
+        next-method-called,
+        next-method-defined,
+        no-absolute-import,
+        no-else-break,
+        no-else-continue,
+        no-else-raise,
+        no-else-return,
+        no-init,  # added
+        no-member,
+        no-name-in-module,
+        no-self-use,
+        nonzero-method,
+        oct-method,
+        old-division,
+        old-ne-operator,
+        old-octal-literal,
+        old-raise-syntax,
+        parameter-unpacking,
+        print-statement,
+        raising-string,
+        range-builtin-not-iterating,
+        raw_input-builtin,
+        rdiv-method,
+        reduce-builtin,
+        relative-import,
+        reload-builtin,
+        round-builtin,
+        setslice-method,
+        signature-differs,
+        standarderror-builtin,
+        suppressed-message,
+        sys-max-int,
+        too-few-public-methods,
+        too-many-ancestors,
+        too-many-arguments,
+        too-many-boolean-expressions,
+        too-many-branches,
+        too-many-instance-attributes,
+        too-many-locals,
+        too-many-nested-blocks,
+        too-many-public-methods,
+        too-many-return-statements,
+        too-many-statements,
+        trailing-newlines,
+        unichr-builtin,
+        unicode-builtin,
+        unnecessary-pass,
+        unpacking-in-except,
+        useless-else-on-loop,
+        useless-object-inheritance,
+        useless-suppression,
+        using-cmp-argument,
+        wrong-import-order,
+        xrange-builtin,
+        zip-builtin-not-iterating,
+
+
+[REPORTS]
+
+# Set the output format. Available formats are text, parseable, colorized, msvs
+# (visual studio) and html. You can also give a reporter class, eg
+# mypackage.mymodule.MyReporterClass.
+output-format=text
+
+# Put messages in a separate file for each module / package specified on the
+# command line instead of printing them on stdout. Reports (if any) will be
+# written in a file name "pylint_global.[txt|html]". This option is deprecated
+# and it will be removed in Pylint 2.0.
+files-output=no
+
+# Tells whether to display a full report or only the messages
+reports=no
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details
+#msg-template=
+
+
+[BASIC]
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=main,_
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Include a hint for the correct naming format with invalid-name
+include-naming-hint=no
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+property-classes=abc.abstractproperty,cached_property.cached_property,cached_property.threaded_cached_property,cached_property.cached_property_with_ttl,cached_property.threaded_cached_property_with_ttl
+
+# Regular expression matching correct function names
+function-rgx=^(?:(?P<exempt>setUp|tearDown|setUpModule|tearDownModule)|(?P<camel_case>_?[A-Z][a-zA-Z0-9]*)|(?P<snake_case>_?[a-z][a-z0-9_]*))$
+
+# Regular expression matching correct variable names
+variable-rgx=^[a-z][a-z0-9_]*$
+
+# Regular expression matching correct constant names
+const-rgx=^(_?[A-Z][A-Z0-9_]*|__[a-z0-9_]+__|_?[a-z][a-z0-9_]*)$
+
+# Regular expression matching correct attribute names
+attr-rgx=^_{0,2}[a-z][a-z0-9_]*$
+
+# Regular expression matching correct argument names
+argument-rgx=^[a-z][a-z0-9_]*$
+
+# Regular expression matching correct class attribute names
+class-attribute-rgx=^(_?[A-Z][A-Z0-9_]*|__[a-z0-9_]+__|_?[a-z][a-z0-9_]*)$
+
+# Regular expression matching correct inline iteration names
+inlinevar-rgx=^[a-z][a-z0-9_]*$
+
+# Regular expression matching correct class names
+class-rgx=^_?[A-Z][a-zA-Z0-9]*$
+
+# Regular expression matching correct module names
+module-rgx=^(_?[a-z][a-z0-9_]*|__init__)$
+
+# Regular expression matching correct method names
+method-rgx=(?x)^(?:(?P<exempt>_[a-z0-9_]+__|runTest|setUp|tearDown|setUpTestCase|tearDownTestCase|setupSelf|tearDownClass|setUpClass|(test|assert)_*[A-Z0-9][a-zA-Z0-9_]*|next)|(?P<camel_case>_{0,2}[A-Z][a-zA-Z0-9_]*)|(?P<snake_case>_{0,2}[a-z][a-z0-9_]*))$
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=(__.*__|main|test.*|.*test|.*Test)$
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=10
+
+
+[TYPECHECK]
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager,contextlib2.contextmanager
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis. It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=
+
+
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=120
+
+# TODO(https://github.com/PyCQA/pylint/issues/3352): Direct pylint to exempt
+# lines made too long by directives to pytype.
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=(?x)(
+  ^\s*(\#\ )?<?https?://\S+>?$|
+  ^\s*(from\s+\S+\s+)?import\s+.+$)
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=yes
+
+# List of optional constructs for which whitespace checking is disabled. `dict-
+# separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
+# `trailing-comma` allows a space between comma and closing bracket: (a, ).
+# `empty-line` allows space-only lines.
+no-space-check=
+
+# Maximum number of lines in a module
+max-module-lines=99999
+
+# String used as indentation unit.  The internal Google style guide mandates 2
+# spaces.  Google's externaly-published style guide says 4, consistent with
+# PEP 8.  Here, we use 2 spaces, for conformity with many open-sourced Google
+# projects (like TensorFlow).
+indent-string='    '
+
+# Number of spaces of indent required inside a hanging  or continued line.
+indent-after-paren=8
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=TODO
+
+
+[STRING]
+
+# This flag controls whether inconsistent-quotes generates a warning when the
+# character used as a quote delimiter is used inconsistently within a module.
+check-quote-consistency=yes
+
+
+[VARIABLES]
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# A regular expression matching the name of dummy variables (i.e. expectedly
+# not used).
+dummy-variables-rgx=^\*{0,2}(_$|unused_|dummy_)
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid to define new builtins when possible.
+additional-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,_cb
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six,six.moves,past.builtins,future.builtins,functools
+
+
+[LOGGING]
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format
+logging-modules=logging,absl.logging,tensorflow.io.logging
+
+
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+
+[SPELLING]
+
+# Spelling dictionary name. Available dictionaries: none. To make it working
+# install python-enchant package.
+spelling-dict=
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to indicated private dictionary in
+# --spelling-private-dict-file option instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[IMPORTS]
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=regsub,
+                   TERMIOS,
+                   Bastion,
+                   rexec,
+                   sets
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled)
+import-graph=
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled)
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant, absl
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+
+[CLASSES]
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,
+                      __new__,
+                      setUp
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,
+                  _fields,
+                  _replace,
+                  _source,
+                  _make
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls,
+                            class_
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "Exception"
+overgeneral-exceptions=StandardError,
+                       Exception,
+                       BaseException