# Access WeakSet through the weakref module.
# This code is separated-out because it is needed
# by abc.py to load everything else at startup.

from _weakref import ref
from types import GenericAlias

__all__ = ['WeakSet']


            

Reported by Pylint.

              # by abc.py to load everything else at startup.

from _weakref import ref
from types import GenericAlias

__all__ = ['WeakSet']


class _IterationGuard:

            

Reported by Pylint.

                      self.weakcontainer = ref(weakcontainer)

    def __enter__(self):
        w = self.weakcontainer()
        if w is not None:
            w._iterating.add(self)
        return self

    def __exit__(self, e, t, b):

            

Reported by Pylint.

                          w._iterating.add(self)
        return self

    def __exit__(self, e, t, b):
        w = self.weakcontainer()
        if w is not None:
            s = w._iterating
            s.remove(self)
            if not s:

            

Reported by Pylint.

                          w._iterating.add(self)
        return self

    def __exit__(self, e, t, b):
        w = self.weakcontainer()
        if w is not None:
            s = w._iterating
            s.remove(self)
            if not s:

            

Reported by Pylint.

                          w._iterating.add(self)
        return self

    def __exit__(self, e, t, b):
        w = self.weakcontainer()
        if w is not None:
            s = w._iterating
            s.remove(self)
            if not s:

            

Reported by Pylint.

                      return self

    def __exit__(self, e, t, b):
        w = self.weakcontainer()
        if w is not None:
            s = w._iterating
            s.remove(self)
            if not s:
                w._commit_removals()

            

Reported by Pylint.

                  def __exit__(self, e, t, b):
        w = self.weakcontainer()
        if w is not None:
            s = w._iterating
            s.remove(self)
            if not s:
                w._commit_removals()



            

Reported by Pylint.

                              w._commit_removals()


class WeakSet:
    def __init__(self, data=None):
        self.data = set()
        def _remove(item, selfref=ref(self)):
            self = selfref()
            if self is not None:

            

Reported by Pylint.

                          self.update(data)

    def _commit_removals(self):
        l = self._pending_removals
        discard = self.data.discard
        while l:
            discard(l.pop())

    def __iter__(self):

            

Reported by Pylint.

              TRY_F = False,    False,    False,   FILES  # '/' in quotes for file name.

# This string includes all chars that may be in an identifier.
# TODO Update this here and elsewhere.
ID_CHARS = string.ascii_letters + string.digits + "_"

SEPS = f"{os.sep}{os.altsep if os.altsep else ''}"
TRIGGERS = f".{SEPS}"


            

Reported by Pylint.

                  def _make_autocomplete_window(self):  # Makes mocking easier.
        return autocomplete_w.AutoCompleteWindow(self.text, tags=self.tags)

    def _remove_autocomplete_window(self, event=None):
        if self.autocompletewindow:
            self.autocompletewindow.hide_window()
            self.autocompletewindow = None

    def force_open_completions_event(self, event):

            

Reported by Pylint.

                          self.autocompletewindow.hide_window()
            self.autocompletewindow = None

    def force_open_completions_event(self, event):
        "(^space) Open completion list, even if a function call is needed."
        self.open_completions(FORCE)
        return "break"

    def autocomplete_event(self, event):

            

Reported by Pylint.

                          opened = self.open_completions(TAB)
            return "break" if opened else None

    def try_open_completions_event(self, event=None):
        "(./) Open completion list after pause with no movement."
        lastchar = self.text.get("insert-1c")
        if lastchar in TRIGGERS:
            args = TRY_A if lastchar == "." else TRY_F
            self._delayed_completion_index = self.text.index("insert")

            

Reported by Pylint.

                          # Find the beginning of the string.
            # fetch_completions will look at the file system to determine
            # whether the string value constitutes an actual file name
            # XXX could consider raw strings here and unescape the string
            # value if it's not raw.
            self._remove_autocomplete_window()
            mode = FILES
            # Find last separator or string start
            while i and curline[i-1] not in "'\"" + SEPS:

            

Reported by Pylint.

                      """
        try:
            rpcclt = self.editwin.flist.pyshell.interp.rpcclt
        except:
            rpcclt = None
        if rpcclt:
            return rpcclt.remotecall("exec", "get_the_completion_list",
                                     (what, mode), {})
        else:

            

Reported by Pylint.

                              if what == "":  # Main module names.
                    namespace = {**__main__.__builtins__.__dict__,
                                 **__main__.__dict__}
                    bigl = eval("dir()", namespace)
                    kwds = (s for s in keyword.kwlist
                            if s not in {'True', 'False', 'None'})
                    bigl.extend(kwds)
                    bigl.sort()
                    if "__all__" in bigl:

            

Reported by Bandit.

                              if what == "":  # Main module names.
                    namespace = {**__main__.__builtins__.__dict__,
                                 **__main__.__dict__}
                    bigl = eval("dir()", namespace)
                    kwds = (s for s in keyword.kwlist
                            if s not in {'True', 'False', 'None'})
                    bigl.extend(kwds)
                    bigl.sort()
                    if "__all__" in bigl:

            

Reported by Pylint.

                                  bigl.extend(kwds)
                    bigl.sort()
                    if "__all__" in bigl:
                        smalll = sorted(eval("__all__", namespace))
                    else:
                        smalll = [s for s in bigl if s[:1] != '_']
                else:
                    try:
                        entity = self.get_entity(what)

            

Reported by Bandit.

                                  bigl.extend(kwds)
                    bigl.sort()
                    if "__all__" in bigl:
                        smalll = sorted(eval("__all__", namespace))
                    else:
                        smalll = [s for s in bigl if s[:1] != '_']
                else:
                    try:
                        entity = self.get_entity(what)

            

Reported by Pylint.

              import linecache
import traceback

from . import base_futures
from . import coroutines


def _task_repr_info(task):
    info = base_futures._future_repr_info(task)

            

Reported by Pylint.

              import linecache
import traceback

from . import base_futures
from . import coroutines


def _task_repr_info(task):
    info = base_futures._future_repr_info(task)

            

Reported by Pylint.

              import traceback

from . import base_futures
from . import coroutines


def _task_repr_info(task):
    info = base_futures._future_repr_info(task)


            

Reported by Pylint.

              

def _task_repr_info(task):
    info = base_futures._future_repr_info(task)

    if task._must_cancel:
        # replace status
        info[0] = 'cancelling'


            

Reported by Pylint.

              def _task_repr_info(task):
    info = base_futures._future_repr_info(task)

    if task._must_cancel:
        # replace status
        info[0] = 'cancelling'

    info.insert(1, 'name=%r' % task.get_name())


            

Reported by Pylint.

              
    info.insert(1, 'name=%r' % task.get_name())

    coro = coroutines._format_coroutine(task._coro)
    info.insert(2, f'coro=<{coro}>')

    if task._fut_waiter is not None:
        info.insert(3, f'wait_for={task._fut_waiter!r}')
    return info

            

Reported by Pylint.

              
    info.insert(1, 'name=%r' % task.get_name())

    coro = coroutines._format_coroutine(task._coro)
    info.insert(2, f'coro=<{coro}>')

    if task._fut_waiter is not None:
        info.insert(3, f'wait_for={task._fut_waiter!r}')
    return info

            

Reported by Pylint.

                  coro = coroutines._format_coroutine(task._coro)
    info.insert(2, f'coro=<{coro}>')

    if task._fut_waiter is not None:
        info.insert(3, f'wait_for={task._fut_waiter!r}')
    return info


def _task_get_stack(task, limit):

            

Reported by Pylint.

                  info.insert(2, f'coro=<{coro}>')

    if task._fut_waiter is not None:
        info.insert(3, f'wait_for={task._fut_waiter!r}')
    return info


def _task_get_stack(task, limit):
    frames = []

            

Reported by Pylint.

              
def _task_get_stack(task, limit):
    frames = []
    if hasattr(task._coro, 'cr_frame'):
        # case 1: 'async def' coroutines
        f = task._coro.cr_frame
    elif hasattr(task._coro, 'gi_frame'):
        # case 2: legacy coroutines
        f = task._coro.gi_frame

            

Reported by Pylint.

                  Args:
        text: Text widget containing the text to be searched.
    """
    root = text._root()
    engine = searchengine.get(root)
    if not hasattr(engine, "_replacedialog"):
        engine._replacedialog = ReplaceDialog(root, engine)
    dialog = engine._replacedialog
    dialog.open(text, insert_tags=insert_tags)

            

Reported by Pylint.

                  root = text._root()
    engine = searchengine.get(root)
    if not hasattr(engine, "_replacedialog"):
        engine._replacedialog = ReplaceDialog(root, engine)
    dialog = engine._replacedialog
    dialog.open(text, insert_tags=insert_tags)


class ReplaceDialog(SearchDialogBase):

            

Reported by Pylint.

                  engine = searchengine.get(root)
    if not hasattr(engine, "_replacedialog"):
        engine._replacedialog = ReplaceDialog(root, engine)
    dialog = engine._replacedialog
    dialog.open(text, insert_tags=insert_tags)


class ReplaceDialog(SearchDialogBase):
    "Dialog for finding and replacing a pattern in text."

            

Reported by Pylint.

                      self.replvar = StringVar(root)
        self.insert_tags = None

    def open(self, text, insert_tags=None):
        """Make dialog visible on top of others and ready to use.

        Also, highlight the currently selected text and set the
        search to include the current selection (self.ok).


            

Reported by Pylint.

                      first = first or text.index("insert")
        last = last or first
        self.show_hit(first, last)
        self.ok = True
        self.insert_tags = insert_tags

    def create_entries(self):
        "Create base and additional label and text entry widgets."
        SearchDialogBase.create_entries(self)

            

Reported by Pylint.

                  def create_entries(self):
        "Create base and additional label and text entry widgets."
        SearchDialogBase.create_entries(self)
        self.replent = self.make_entry("Replace with:", self.replvar)[0]

    def create_command_buttons(self):
        """Create base and additional command buttons.

        The additional buttons are for Find, Replace,

            

Reported by Pylint.

                      self.make_button("Replace+Find", self.default_command, isdef=True)
        self.make_button("Replace All", self.replace_all)

    def find_it(self, event=None):
        "Handle the Find button."
        self.do_find(False)

    def replace_it(self, event=None):
        """Handle the Replace button.

            

Reported by Pylint.

                      "Handle the Find button."
        self.do_find(False)

    def replace_it(self, event=None):
        """Handle the Replace button.

        If the find is successful, then perform replace.
        """
        if self.do_find(self.ok):

            

Reported by Pylint.

                      if self.do_find(self.ok):
            self.do_replace()

    def default_command(self, event=None):
        """Handle the Replace+Find button as the default command.

        First performs a replace and then, if the replace was
        successful, a find next.
        """

            

Reported by Pylint.

              
        return new

    def replace_all(self, event=None):
        """Handle the Replace All button.

        Search text for occurrences of the Find value and replace
        each of them.  The 'wrap around' value controls the start
        point for searching.  If wrap isn't set, then the searching

            

Reported by Pylint.

                          output = str(fnfe)
        if output != "probe: success":
            raise unittest.SkipTest(
                "{}(1) failed: {}".format(self.COMMAND[0], output)
            )


class DTraceBackend(TraceBackend):
    EXTENSION = ".d"

            

Reported by Pylint.

                      result = [row[1] for row in result]
        return "\n".join(result)
    except (IndexError, ValueError):
        raise AssertionError(
            "tracer produced unparseable output:\n{}".format(output)
        )


class TraceBackend:

            

Reported by Pylint.

              import dis
import os.path
import re
import subprocess
import sys
import types
import unittest

from test.support import findfile, run_unittest

            

Reported by Pylint.

              import dis
import os.path
import re
import subprocess
import sys
import types
import unittest

from test.support import findfile, run_unittest

            

Reported by Bandit.

              from test.support import findfile, run_unittest


def abspath(filename):
    return os.path.abspath(findfile(filename, subdir="dtracedata"))


def normalize_trace_output(output):
    """Normalize DTrace output for comparison.

            

Reported by Pylint.

                      )


class TraceBackend:
    EXTENSION = None
    COMMAND = None
    COMMAND_ARGS = []

    def run_case(self, name, optimize_python=None):

            

Reported by Pylint.

                  COMMAND = None
    COMMAND_ARGS = []

    def run_case(self, name, optimize_python=None):
        actual_output = normalize_trace_output(self.trace_python(
            script_file=abspath(name + self.EXTENSION),
            python_file=abspath(name + ".py"),
            optimize_python=optimize_python))


            

Reported by Pylint.

                          python_file=abspath(name + ".py"),
            optimize_python=optimize_python))

        with open(abspath(name + self.EXTENSION + ".expected")) as f:
            expected_output = f.read().rstrip()

        return (expected_output, actual_output)

    def generate_trace_command(self, script_file, subcommand=None):

            

Reported by Pylint.

              
        return (expected_output, actual_output)

    def generate_trace_command(self, script_file, subcommand=None):
        command = self.COMMAND + [script_file]
        if subcommand:
            command += ["-c", subcommand]
        return command


            

Reported by Pylint.

                          command += ["-c", subcommand]
        return command

    def trace(self, script_file, subcommand=None):
        command = self.generate_trace_command(script_file, subcommand)
        stdout, _ = subprocess.Popen(command,
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.STDOUT,
                                     universal_newlines=True).communicate()

            

Reported by Pylint.

              if sys.platform != 'win32':
    raise unittest.SkipTest('Windows only')

import _overlapped
import _winapi

import asyncio
from asyncio import windows_utils
from test import support

            

Reported by Pylint.

                  raise unittest.SkipTest('Windows only')

import _overlapped
import _winapi

import asyncio
from asyncio import windows_utils
from test import support


            

Reported by Pylint.

                          try:
                ov1.getresult()
            except OSError as e:
                self.assertEqual(e.winerror, ERROR_IO_INCOMPLETE)
            else:
                raise RuntimeError('expected ERROR_IO_INCOMPLETE')

            ov2 = _overlapped.Overlapped()
            self.assertFalse(ov2.pending)

            

Reported by Pylint.

                      try:
            _winapi.CloseHandle(h)
        except OSError as e:
            self.assertEqual(e.winerror, 6)     # ERROR_INVALID_HANDLE
        else:
            raise RuntimeError('expected ERROR_INVALID_HANDLE')


class PopenTests(unittest.TestCase):

            

Reported by Pylint.

              if sys.platform != 'win32':
    raise unittest.SkipTest('Windows only')

import _overlapped
import _winapi

import asyncio
from asyncio import windows_utils
from test import support

            

Reported by Pylint.

                  raise unittest.SkipTest('Windows only')

import _overlapped
import _winapi

import asyncio
from asyncio import windows_utils
from test import support


            

Reported by Pylint.

              import _overlapped
import _winapi

import asyncio
from asyncio import windows_utils
from test import support


def tearDownModule():

            

Reported by Pylint.

              import _overlapped
import _winapi

import asyncio
from asyncio import windows_utils
from test import support


def tearDownModule():

            

Reported by Pylint.

              import _winapi

import asyncio
from asyncio import windows_utils
from test import support


def tearDownModule():
    asyncio.set_event_loop_policy(None)

            

Reported by Pylint.

              import _winapi

import asyncio
from asyncio import windows_utils
from test import support


def tearDownModule():
    asyncio.set_event_loop_policy(None)

            

Reported by Pylint.

                                  "File and directory compare as equal")

    def test_cache_clear(self):
        first_compare = filecmp.cmp(self.name, self.name_same, shallow=False)
        second_compare = filecmp.cmp(self.name, self.name_diff, shallow=False)
        filecmp.clear_cache()
        self.assertTrue(len(filecmp._cache) == 0,
                        "Cache not cleared after calling clear_cache")


            

Reported by Pylint.

              
    def test_cache_clear(self):
        first_compare = filecmp.cmp(self.name, self.name_same, shallow=False)
        second_compare = filecmp.cmp(self.name, self.name_diff, shallow=False)
        filecmp.clear_cache()
        self.assertTrue(len(filecmp._cache) == 0,
                        "Cache not cleared after calling clear_cache")

class DirCompareTestCase(unittest.TestCase):

            

Reported by Pylint.

                      first_compare = filecmp.cmp(self.name, self.name_same, shallow=False)
        second_compare = filecmp.cmp(self.name, self.name_diff, shallow=False)
        filecmp.clear_cache()
        self.assertTrue(len(filecmp._cache) == 0,
                        "Cache not cleared after calling clear_cache")

class DirCompareTestCase(unittest.TestCase):
    def setUp(self):
        tmpdir = tempfile.gettempdir()

            

Reported by Pylint.

              
        self.caseinsensitive = os.path.normcase('A') == os.path.normcase('a')
        data = 'Contents of file go here.\n'
        for dir in (self.dir, self.dir_same, self.dir_diff, self.dir_ignored):
            shutil.rmtree(dir, True)
            os.mkdir(dir)
            subdir_path = os.path.join(dir, 'subdir')
            os.mkdir(subdir_path)
            if self.caseinsensitive and dir is self.dir_same:

            

Reported by Pylint.

                          output.write('An extra file.\n')

    def tearDown(self):
        for dir in (self.dir, self.dir_same, self.dir_diff):
            shutil.rmtree(dir)

    def test_default_ignores(self):
        self.assertIn('.hg', filecmp.DEFAULT_IGNORES)


            

Reported by Pylint.

              import filecmp
import os
import shutil
import tempfile
import unittest

from test import support
from test.support import os_helper


            

Reported by Pylint.

              from test.support import os_helper


class FileCompareTestCase(unittest.TestCase):
    def setUp(self):
        self.name = os_helper.TESTFN
        self.name_same = os_helper.TESTFN + '-same'
        self.name_diff = os_helper.TESTFN + '-diff'
        data = 'Contents of file go here.\n'

            

Reported by Pylint.

                      os.unlink(self.name_same)
        os.unlink(self.name_diff)

    def test_matching(self):
        self.assertTrue(filecmp.cmp(self.name, self.name),
                        "Comparing file to itself fails")
        self.assertTrue(filecmp.cmp(self.name, self.name, shallow=False),
                        "Comparing file to itself fails")
        self.assertTrue(filecmp.cmp(self.name, self.name_same),

            

Reported by Pylint.

                      self.assertTrue(filecmp.cmp(self.name, self.name_same, shallow=False),
                        "Comparing file to identical file fails")

    def test_different(self):
        self.assertFalse(filecmp.cmp(self.name, self.name_diff),
                    "Mismatched files compare as equal")
        self.assertFalse(filecmp.cmp(self.name, self.dir),
                    "File and directory compare as equal")


            

Reported by Pylint.

                      self.assertFalse(filecmp.cmp(self.name, self.dir),
                    "File and directory compare as equal")

    def test_cache_clear(self):
        first_compare = filecmp.cmp(self.name, self.name_same, shallow=False)
        second_compare = filecmp.cmp(self.name, self.name_diff, shallow=False)
        filecmp.clear_cache()
        self.assertTrue(len(filecmp._cache) == 0,
                        "Cache not cleared after calling clear_cache")

            

Reported by Pylint.

              
class HTTPSServer(_HTTPServer):

    def __init__(self, server_address, handler_class, context):
        _HTTPServer.__init__(self, server_address, handler_class)
        self.context = context

    def __str__(self):
        return ('<%s %s:%s>' %

            

Reported by Pylint.

              
class HTTPSServer(_HTTPServer):

    def __init__(self, server_address, handler_class, context):
        _HTTPServer.__init__(self, server_address, handler_class)
        self.context = context

    def __str__(self):
        return ('<%s %s:%s>' %

            

Reported by Pylint.

                      words = filter(None, words)
        path = self.root
        for word in words:
            drive, word = os.path.splitdrive(word)
            head, word = os.path.split(word)
            path = os.path.join(path, word)
        return path

    def log_message(self, format, *args):

            

Reported by Pylint.

                      path = self.root
        for word in words:
            drive, word = os.path.splitdrive(word)
            head, word = os.path.split(word)
            path = os.path.join(path, word)
        return path

    def log_message(self, format, *args):
        # we override this to suppress logging unless "verbose"

            

Reported by Pylint.

                          path = os.path.join(path, word)
        return path

    def log_message(self, format, *args):
        # we override this to suppress logging unless "verbose"
        if support.verbose:
            sys.stdout.write(" server (%s:%d %s):\n   [%s] %s\n" %
                             (self.server.server_address,
                              self.server.server_port,

            

Reported by Pylint.

                          path = os.path.join(path, word)
        return path

    def log_message(self, format, *args):
        # we override this to suppress logging unless "verbose"
        if support.verbose:
            sys.stdout.write(" server (%s:%d %s):\n   [%s] %s\n" %
                             (self.server.server_address,
                              self.server.server_port,

            

Reported by Pylint.

              
    def do_GET(self, send_body=True):
        """Serve a GET request."""
        sock = self.rfile.raw._sock
        context = sock.context
        stats = {
            'session_cache': context.session_stats(),
            'cipher': sock.cipher(),
            'compression': sock.compression(),

            

Reported by Pylint.

                  def do_GET(self, send_body=True):
        """Serve a GET request."""
        sock = self.rfile.raw._sock
        context = sock.context
        stats = {
            'session_cache': context.session_stats(),
            'cipher': sock.cipher(),
            'compression': sock.compression(),
            }

            

Reported by Pylint.

                      """Serve a HEAD request."""
        self.do_GET(send_body=False)

    def log_request(self, format, *args):
        if support.verbose:
            BaseHTTPRequestHandler.log_request(self, format, *args)


class HTTPSServerThread(threading.Thread):

            

Reported by Pylint.

                      """Serve a HEAD request."""
        self.do_GET(send_body=False)

    def log_request(self, format, *args):
        if support.verbose:
            BaseHTTPRequestHandler.log_request(self, format, *args)


class HTTPSServerThread(threading.Thread):

            

Reported by Pylint.

              
def main():
    total, d = None, {}
    with os.popen('du ' + ' '.join(sys.argv[1:])) as p:
        for line in p:
            i = 0
            while line[i] in '0123456789': i = i+1
            size = eval(line[:i])
            while line[i] in ' \t': i = i+1

            

Reported by Bandit.

                      for line in p:
            i = 0
            while line[i] in '0123456789': i = i+1
            size = eval(line[:i])
            while line[i] in ' \t': i = i+1
            filename = line[i:-1]
            comps = filename.split('/')
            if comps[0] == '': comps[0] = '/'
            if comps[len(comps)-1] == '': del comps[len(comps)-1]

            

Reported by Pylint.

                      for line in p:
            i = 0
            while line[i] in '0123456789': i = i+1
            size = eval(line[:i])
            while line[i] in ' \t': i = i+1
            filename = line[i:-1]
            comps = filename.split('/')
            if comps[0] == '': comps[0] = '/'
            if comps[len(comps)-1] == '': del comps[len(comps)-1]

            

Reported by Bandit.

              def display(total, d):
    show(total, d, '')

def show(total, d, prefix):
    if not d: return
    list = []
    sum = 0
    for key in d.keys():
        tsub, dsub = d[key]

            

Reported by Pylint.

              
def show(total, d, prefix):
    if not d: return
    list = []
    sum = 0
    for key in d.keys():
        tsub, dsub = d[key]
        list.append((tsub, key))
        if tsub is not None: sum = sum + tsub

            

Reported by Pylint.

              def show(total, d, prefix):
    if not d: return
    list = []
    sum = 0
    for key in d.keys():
        tsub, dsub = d[key]
        list.append((tsub, key))
        if tsub is not None: sum = sum + tsub
##  if sum < total:

            

Reported by Pylint.

                  list = []
    sum = 0
    for key in d.keys():
        tsub, dsub = d[key]
        list.append((tsub, key))
        if tsub is not None: sum = sum + tsub
##  if sum < total:
##      list.append((total - sum, os.curdir))
    list.sort()

            

Reported by Pylint.

              #! /usr/bin/env python3
# Format du output in a tree shape

import os, sys, errno

def main():
    total, d = None, {}
    with os.popen('du ' + ' '.join(sys.argv[1:])) as p:
        for line in p:

            

Reported by Pylint.

              #! /usr/bin/env python3
# Format du output in a tree shape

import os, sys, errno

def main():
    total, d = None, {}
    with os.popen('du ' + ' '.join(sys.argv[1:])) as p:
        for line in p:

            

Reported by Pylint.

              
import os, sys, errno

def main():
    total, d = None, {}
    with os.popen('du ' + ' '.join(sys.argv[1:])) as p:
        for line in p:
            i = 0
            while line[i] in '0123456789': i = i+1

            

Reported by Pylint.

                  if LOG:
        return

    LOG = logging.getLogger("make_layout")
    LOG.level = logging.DEBUG

    if ns.v:
        s_level = max(logging.ERROR - ns.v * 10, logging.DEBUG)
        f_level = max(logging.WARNING - ns.v * 10, logging.DEBUG)

            

Reported by Pylint.

                      return

    LOG = logging.getLogger("make_layout")
    LOG.level = logging.DEBUG

    if ns.v:
        s_level = max(logging.ERROR - ns.v * 10, logging.DEBUG)
        f_level = max(logging.WARNING - ns.v * 10, logging.DEBUG)
    else:

            

Reported by Pylint.

                  LOG.level = logging.DEBUG

    if ns.v:
        s_level = max(logging.ERROR - ns.v * 10, logging.DEBUG)
        f_level = max(logging.WARNING - ns.v * 10, logging.DEBUG)
    else:
        s_level = logging.ERROR
        f_level = logging.INFO


            

Reported by Pylint.

                  LOG.level = logging.DEBUG

    if ns.v:
        s_level = max(logging.ERROR - ns.v * 10, logging.DEBUG)
        f_level = max(logging.WARNING - ns.v * 10, logging.DEBUG)
    else:
        s_level = logging.ERROR
        f_level = logging.INFO


            

Reported by Pylint.

              
    if ns.v:
        s_level = max(logging.ERROR - ns.v * 10, logging.DEBUG)
        f_level = max(logging.WARNING - ns.v * 10, logging.DEBUG)
    else:
        s_level = logging.ERROR
        f_level = logging.INFO

    handler = logging.StreamHandler(sys.stdout)

            

Reported by Pylint.

              
    if ns.v:
        s_level = max(logging.ERROR - ns.v * 10, logging.DEBUG)
        f_level = max(logging.WARNING - ns.v * 10, logging.DEBUG)
    else:
        s_level = logging.ERROR
        f_level = logging.INFO

    handler = logging.StreamHandler(sys.stdout)

            

Reported by Pylint.

                      s_level = max(logging.ERROR - ns.v * 10, logging.DEBUG)
        f_level = max(logging.WARNING - ns.v * 10, logging.DEBUG)
    else:
        s_level = logging.ERROR
        f_level = logging.INFO

    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(logging.Formatter("{levelname:8s} {message}", style="{"))
    handler.setLevel(s_level)

            

Reported by Pylint.

                      f_level = max(logging.WARNING - ns.v * 10, logging.DEBUG)
    else:
        s_level = logging.ERROR
        f_level = logging.INFO

    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(logging.Formatter("{levelname:8s} {message}", style="{"))
    handler.setLevel(s_level)
    LOG.addHandler(handler)

            

Reported by Pylint.

                      s_level = logging.ERROR
        f_level = logging.INFO

    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(logging.Formatter("{levelname:8s} {message}", style="{"))
    handler.setLevel(s_level)
    LOG.addHandler(handler)

    if ns.log:

            

Reported by Pylint.

                      f_level = logging.INFO

    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(logging.Formatter("{levelname:8s} {message}", style="{"))
    handler.setLevel(s_level)
    LOG.addHandler(handler)

    if ns.log:
        handler = logging.FileHandler(ns.log, encoding="utf-8", delay=True)

            

Reported by Pylint.