glances.outputs.glances_curses

Complexity

Total Complexity

182

Size/Duplication

Total Lines	1069
Duplicated Lines	0 %

Importance

Changes

0

36 Methods

Rating	Name	Duplication	Size	Complexity
A	_GlancesCurses.new_column()	0	3	1
A	_GlancesCurses.enable_fullquicklook()	0	5	2
A	_GlancesCurses.disable_top()	0	4	2
B	_GlancesCurses.update()	0	48	6
A	_GlancesCurses.__init__()	0	48	2
A	_GlancesCurses.end()	0	12	5
A	_GlancesCurses.flush()	0	11	1
A	_GlancesCurses.__get_stat_display()	0	34	5
A	_GlancesCurses.get_stats_display_width()	0	16	5
F	_GlancesCurses.display()	0	113	16
A	_GlancesCurses.erase()	0	3	1
A	_GlancesCurses.new_line()	0	3	1
C	_GlancesCurses.display_popup()	0	77	11
A	_GlancesCurses.init_column()	0	4	1
A	_GlancesCurses.get_stats_display_height()	0	12	3
B	_GlancesCurses.__display_left()	0	12	6
A	_GlancesCurses.init_line()	0	4	1
A	_GlancesCurses.wait()	0	3	1
A	_GlancesCurses.disable_fullquicklook()	0	4	2
F	_GlancesCurses.__display_top()	0	74	16
A	_GlancesCurses._init_cursor()	0	8	3
A	GlancesTextbox.do_command()	0	6	3
B	_GlancesCurses.__display_right()	0	28	8
A	_GlancesCurses.init_line_column()	0	4	1
A	_GlancesCurses._init_history()	0	4	1
F	_GlancesCurses._init_colors()	0	113	13
F	_GlancesCurses.__catch_key()	0	82	26
A	_GlancesCurses.get_key()	0	5	1
A	_GlancesCurses.enable_top()	0	4	2
A	_GlancesCurses.loop_position()	0	6	3
A	_GlancesCurses.__display_header()	0	27	3
A	_GlancesCurses.is_theme()	0	3	1
A	GlancesTextbox.__init__()	0	2	1
A	_GlancesCurses.load_config()	0	7	3
A	_GlancesCurses.set_cursor()	0	12	3
F	_GlancesCurses.display_plugin()	0	91	22

# -*- coding: utf-8 -*-

Too many lines in module (1068/1000)

#
# This file is part of Glances.
#
# Copyright (C) 2019 Nicolargo <nicolas@nicolargo.com>
#
# Glances is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Glances is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.

"""Curses interface class."""
from __future__ import unicode_literals

import re

import missing from __future__ import absolute_import

The import re seems to be unused.

import sys

import missing from __future__ import absolute_import

from glances.compat import to_ascii, nativestr, b, u, itervalues

import missing from __future__ import absolute_import

Unused to_ascii imported from glances.compat

Unused b imported from glances.compat

from glances.globals import MACOS, WINDOWS

import missing from __future__ import absolute_import

from glances.logger import logger

import missing from __future__ import absolute_import

from glances.events import glances_events

import missing from __future__ import absolute_import

from glances.processes import glances_processes

import missing from __future__ import absolute_import

from glances.timer import Timer

import missing from __future__ import absolute_import

# Import curses library for "normal" operating system
if not WINDOWS:
    try:
        import curses

import missing from __future__ import absolute_import

        import curses.panel

import missing from __future__ import absolute_import

        from curses.textpad import Textbox

import missing from __future__ import absolute_import

    except ImportError:
        logger.critical("Curses module not found. Glances cannot start in standalone mode.")

This line is too long as per the coding-style (92/80).

        sys.exit(1)


class _GlancesCurses(object):

Too many instance attributes (33/7)

Too many public methods (24/20)

    """This class manages the curses display (and key pressed).

    Note: It is a private class, use GlancesCursesClient or GlancesCursesBrowser.

This line is too long as per the coding-style (81/80).

    """

    _hotkeys = {
        '0': {'switch': 'disable_irix'},
        '1': {'switch': 'percpu'},
        '2': {'switch': 'disable_left_sidebar'},
        '3': {'switch': 'disable_quicklook'},
        '6': {'switch': 'meangpu'},
        '/': {'switch': 'process_short_name'},
        'A': {'switch': 'disable_amps'},
        'b': {'switch': 'byte'},
        'B': {'switch': 'diskio_iops'},
        'C': {'switch': 'disable_cloud'},
        'D': {'switch': 'disable_docker'},
        'd': {'switch': 'disable_diskio'},
        'F': {'switch': 'fs_free_space'},
        'g': {'switch': 'generate_graph'},
        'G': {'switch': 'disable_gpu'},
        'h': {'switch': 'help_tag'},
        'I': {'switch': 'disable_ip'},
        'k': {'switch': 'disable_connections'},
        'l': {'switch': 'disable_alert'},
        'M': {'switch': 'reset_minmax_tag'},
        'n': {'switch': 'disable_network'},
        'N': {'switch': 'disable_now'},
        'P': {'switch': 'disable_ports'},
        'Q': {'switch': 'enable_irq'},
        'R': {'switch': 'disable_raid'},
        's': {'switch': 'disable_sensors'},
        'S': {'switch': 'sparkline'},
        'T': {'switch': 'network_sum'},
        'U': {'switch': 'network_cumul'},
        'W': {'switch': 'disable_wifi'},
        # Processes sort hotkeys
        'a': {'auto_sort': True, 'sort_key': 'cpu_percent'},
        'c': {'auto_sort': False, 'sort_key': 'cpu_percent'},
        'i': {'auto_sort': False, 'sort_key': 'io_counters'},
        'm': {'auto_sort': False, 'sort_key': 'memory_percent'},
        'p': {'auto_sort': False, 'sort_key': 'name'},
        't': {'auto_sort': False, 'sort_key': 'cpu_times'},
        'u': {'auto_sort': False, 'sort_key': 'username'},
    }

    _sort_loop = ['cpu_percent', 'memory_percent', 'username',
                  'cpu_times', 'io_counters', 'name']

    # Define top menu
    _top = ['quicklook', 'cpu', 'percpu', 'gpu', 'mem', 'memswap', 'load']
    _quicklook_max_width = 68

    # Define left sidebar
    _left_sidebar = ['network', 'connections', 'wifi', 'ports', 'diskio', 'fs',
                     'irq', 'folders', 'raid', 'sensors', 'now']
    _left_sidebar_min_width = 23
    _left_sidebar_max_width = 34

    # Define right sidebar
    _right_sidebar = ['docker', 'processcount', 'amps', 'processlist', 'alert']

    def __init__(self, config=None, args=None):
        # Init
        self.config = config
        self.args = args

        # Init windows positions
        self.term_w = 80
        self.term_h = 24

        # Space between stats
        self.space_between_column = 3
        self.space_between_line = 2

        # Init the curses screen
        self.screen = curses.initscr()

The variable curses does not seem to be defined in case BooleanNotNode on line 34 is False. Are you sure this can never be the case?

        if not self.screen:
            logger.critical("Cannot init the curses library.\n")
            sys.exit(1)

        # Load the 'outputs' section of the configuration file
        # - Init the theme (default is black)
        self.theme = {'name': 'black'}

        # Load configuration file
        self.load_config(config)

        # Init cursor
        self._init_cursor()

        # Init the colors
        self._init_colors()

        # Init main window
        self.term_window = self.screen.subwin(0, 0)

        # Init edit filter tag
        self.edit_filter = False

        # Init the process min/max reset
        self.args.reset_minmax_tag = False

        # Catch key pressed with non blocking mode
        self.term_window.keypad(1)
        self.term_window.nodelay(1)
        self.pressedkey = -1

        # History tag
        self._init_history()

    def load_config(self, config):
        """Load the outputs section of the configuration file."""
        # Load the theme
        if config is not None and config.has_section('outputs'):
            logger.debug('Read the outputs section in the configuration file')
            self.theme['name'] = config.get_value('outputs', 'curse_theme', default='black')

This line is too long as per the coding-style (92/80).

            logger.debug('Theme for the curse interface: {}'.format(self.theme['name']))

This line is too long as per the coding-style (88/80).

Use formatting in logging functions and pass the parameters as arguments

    def is_theme(self, name):
        """Return True if the theme *name* should be used."""
        return getattr(self.args, 'theme_' + name) or self.theme['name'] == name

    def _init_history(self):
        """Init the history option."""

        self.reset_history_tag = False

    def _init_cursor(self):
        """Init cursors."""

        if hasattr(curses, 'noecho'):

The variable curses does not seem to be defined in case BooleanNotNode on line 34 is False. Are you sure this can never be the case?

            curses.noecho()

The Module curses does not seem to have a member named noecho.

        if hasattr(curses, 'cbreak'):
            curses.cbreak()

The Module curses does not seem to have a member named cbreak.

        self.set_cursor(0)

    def _init_colors(self):
        """Init the Curses color layout."""

        # Set curses options
        try:
            if hasattr(curses, 'start_color'):

The variable curses does not seem to be defined in case BooleanNotNode on line 34 is False. Are you sure this can never be the case?

                curses.start_color()
            if hasattr(curses, 'use_default_colors'):
                curses.use_default_colors()

The Module curses does not seem to have a member named use_default_colors.

        except Exception as e:

Catching very general exceptions such as Exception is usually not recommended.

The name e does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            logger.warning('Error initializing terminal color ({})'.format(e))

Use formatting in logging functions and pass the parameters as arguments

        # Init colors
        if self.args.disable_bold:
            A_BOLD = 0

The name A_BOLD does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            self.args.disable_bg = True
        else:
            A_BOLD = curses.A_BOLD

The name A_BOLD does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        self.title_color = A_BOLD
        self.title_underline_color = A_BOLD | curses.A_UNDERLINE
        self.help_color = A_BOLD

        if curses.has_colors():

The Module curses does not seem to have a member named has_colors.

            # The screen is compatible with a colored design
            if self.is_theme('white'):
                # White theme: black ==> white
                curses.init_pair(1, curses.COLOR_BLACK, -1)

The Module curses does not seem to have a member named init_pair.

            else:
                curses.init_pair(1, curses.COLOR_WHITE, -1)

The Module curses does not seem to have a member named init_pair.

            if self.args.disable_bg:
                curses.init_pair(2, curses.COLOR_RED, -1)

The Module curses does not seem to have a member named init_pair.

                curses.init_pair(3, curses.COLOR_GREEN, -1)

The Module curses does not seem to have a member named init_pair.

                curses.init_pair(4, curses.COLOR_BLUE, -1)

The Module curses does not seem to have a member named init_pair.

                curses.init_pair(5, curses.COLOR_MAGENTA, -1)

The Module curses does not seem to have a member named init_pair.

            else:
                curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_RED)

The Module curses does not seem to have a member named init_pair.

                curses.init_pair(3, curses.COLOR_WHITE, curses.COLOR_GREEN)

The Module curses does not seem to have a member named init_pair.

                curses.init_pair(4, curses.COLOR_WHITE, curses.COLOR_BLUE)

The Module curses does not seem to have a member named init_pair.

                curses.init_pair(5, curses.COLOR_WHITE, curses.COLOR_MAGENTA)

The Module curses does not seem to have a member named init_pair.

            curses.init_pair(6, curses.COLOR_RED, -1)

The Module curses does not seem to have a member named init_pair.

            curses.init_pair(7, curses.COLOR_GREEN, -1)

The Module curses does not seem to have a member named init_pair.

            curses.init_pair(8, curses.COLOR_BLUE, -1)

The Module curses does not seem to have a member named init_pair.

            # Colors text styles
            if curses.COLOR_PAIRS > 8:
                try:
                    curses.init_pair(9, curses.COLOR_MAGENTA, -1)

The Module curses does not seem to have a member named init_pair.

                except Exception:

Catching very general exceptions such as Exception is usually not recommended.

                    if self.is_theme('white'):
                        curses.init_pair(9, curses.COLOR_BLACK, -1)

The Module curses does not seem to have a member named init_pair.

                    else:
                        curses.init_pair(9, curses.COLOR_WHITE, -1)

The Module curses does not seem to have a member named init_pair.

                try:
                    curses.init_pair(10, curses.COLOR_CYAN, -1)

The Module curses does not seem to have a member named init_pair.

                except Exception:

Catching very general exceptions such as Exception is usually not recommended.

                    if self.is_theme('white'):
                        curses.init_pair(10, curses.COLOR_BLACK, -1)

The Module curses does not seem to have a member named init_pair.

                    else:
                        curses.init_pair(10, curses.COLOR_WHITE, -1)

The Module curses does not seem to have a member named init_pair.

                self.ifWARNING_color2 = curses.color_pair(9) | A_BOLD

The name ifWARNING_color2 does not conform to the attribute naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The Module curses does not seem to have a member named color_pair.

                self.ifCRITICAL_color2 = curses.color_pair(6) | A_BOLD

The name ifCRITICAL_color2 does not conform to the attribute naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The Module curses does not seem to have a member named color_pair.

                self.filter_color = curses.color_pair(10) | A_BOLD

The Module curses does not seem to have a member named color_pair.

            self.no_color = curses.color_pair(1)

The Module curses does not seem to have a member named color_pair.

            self.default_color = curses.color_pair(3) | A_BOLD

The Module curses does not seem to have a member named color_pair.

            self.nice_color = curses.color_pair(9)

The Module curses does not seem to have a member named color_pair.

            self.cpu_time_color = curses.color_pair(9)

The Module curses does not seem to have a member named color_pair.

            self.ifCAREFUL_color = curses.color_pair(4) | A_BOLD

The Module curses does not seem to have a member named color_pair.

The name ifCAREFUL_color does not conform to the attribute naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            self.ifWARNING_color = curses.color_pair(5) | A_BOLD

The name ifWARNING_color does not conform to the attribute naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The Module curses does not seem to have a member named color_pair.

            self.ifCRITICAL_color = curses.color_pair(2) | A_BOLD

The name ifCRITICAL_color does not conform to the attribute naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The Module curses does not seem to have a member named color_pair.

            self.default_color2 = curses.color_pair(7)

The Module curses does not seem to have a member named color_pair.

            self.ifCAREFUL_color2 = curses.color_pair(8) | A_BOLD

The name ifCAREFUL_color2 does not conform to the attribute naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The Module curses does not seem to have a member named color_pair.

        else:
            # The screen is NOT compatible with a colored design
            # switch to B&W text styles
            self.no_color = curses.A_NORMAL
            self.default_color = curses.A_NORMAL
            self.nice_color = A_BOLD
            self.cpu_time_color = A_BOLD
            self.ifCAREFUL_color = curses.A_UNDERLINE
            self.ifWARNING_color = A_BOLD
            self.ifCRITICAL_color = curses.A_REVERSE
            self.default_color2 = curses.A_NORMAL
            self.ifCAREFUL_color2 = curses.A_UNDERLINE
            self.ifWARNING_color2 = A_BOLD
            self.ifCRITICAL_color2 = curses.A_REVERSE
            self.filter_color = A_BOLD

        # Define the colors list (hash table) for stats
        self.colors_list = {
            'DEFAULT': self.no_color,
            'UNDERLINE': curses.A_UNDERLINE,
            'BOLD': A_BOLD,
            'SORT': A_BOLD,
            'OK': self.default_color2,
            'MAX': self.default_color2 | curses.A_BOLD,
            'FILTER': self.filter_color,
            'TITLE': self.title_color,
            'PROCESS': self.default_color2,
            'STATUS': self.default_color2,
            'NICE': self.nice_color,
            'CPU_TIME': self.cpu_time_color,
            'CAREFUL': self.ifCAREFUL_color2,
            'WARNING': self.ifWARNING_color2,
            'CRITICAL': self.ifCRITICAL_color2,
            'OK_LOG': self.default_color,
            'CAREFUL_LOG': self.ifCAREFUL_color,
            'WARNING_LOG': self.ifWARNING_color,
            'CRITICAL_LOG': self.ifCRITICAL_color,
            'PASSWORD': curses.A_PROTECT
        }

    def set_cursor(self, value):

This method could be written as a function/class method.

        """Configure the curse cursor apparence.

        0: invisible
        1: visible
        2: very visible
        """
        if hasattr(curses, 'curs_set'):

The variable curses does not seem to be defined in case BooleanNotNode on line 34 is False. Are you sure this can never be the case?

            try:
                curses.curs_set(value)

The Module curses does not seem to have a member named curs_set.

            except Exception:

Catching very general exceptions such as Exception is usually not recommended.

                pass

    # def get_key(self, window):
    #     # Catch ESC key AND numlock key (issue #163)
    #     keycode = [0, 0]
    #     keycode[0] = window.getch()
    #     keycode[1] = window.getch()
    #
    #     if keycode != [-1, -1]:
    #         logger.debug("Keypressed (code: %s)" % keycode)
    #
    #     if keycode[0] == 27 and keycode[1] != -1:
    #         # Do not escape on specials keys
    #         return -1
    #     else:
    #         return keycode[0]

    def get_key(self, window):

This method should have a docstring.

This method could be written as a function/class method.

        # @TODO: Check issue #163
        ret = window.getch()
        logger.debug("Keypressed (code: %s)" % ret)

Specify string format arguments as logging function parameters

        return ret

    def __catch_key(self, return_to_browser=False):
        # Catch the pressed key
        self.pressedkey = self.get_key(self.term_window)

        # Actions (available in the global hotkey dict)...
        for hotkey in self._hotkeys:
            if self.pressedkey == ord(hotkey) and 'switch' in self._hotkeys[hotkey]:

This line is too long as per the coding-style (84/80).

                setattr(self.args,
                        self._hotkeys[hotkey]['switch'],
                        not getattr(self.args,
                                    self._hotkeys[hotkey]['switch']))
            if self.pressedkey == ord(hotkey) and 'auto_sort' in self._hotkeys[hotkey]:

This line is too long as per the coding-style (87/80).

                setattr(glances_processes,
                        'auto_sort',
                        self._hotkeys[hotkey]['auto_sort'])
            if self.pressedkey == ord(hotkey) and 'sort_key' in self._hotkeys[hotkey]:

This line is too long as per the coding-style (86/80).

                setattr(glances_processes,
                        'sort_key',
                        self._hotkeys[hotkey]['sort_key'])

        # Other actions...
        if self.pressedkey == ord('\x1b') or self.pressedkey == ord('q'):
            # 'ESC'|'q' > Quit
            if return_to_browser:
                logger.info("Stop Glances client and return to the browser")
            else:
                logger.info("Stop Glances (keypressed: {})".format(self.pressedkey))

This line is too long as per the coding-style (84/80).

Use formatting in logging functions and pass the parameters as arguments

        elif self.pressedkey == ord('\n'):
            # 'ENTER' > Edit the process filter
            self.edit_filter = not self.edit_filter
        elif self.pressedkey == ord('4'):
            self.args.full_quicklook = not self.args.full_quicklook
            if self.args.full_quicklook:
                self.enable_fullquicklook()
            else:
                self.disable_fullquicklook()
        elif self.pressedkey == ord('5'):
            self.args.disable_top = not self.args.disable_top
            if self.args.disable_top:
                self.disable_top()
            else:
                self.enable_top()
        elif self.pressedkey == ord('e'):
            # 'e' > Enable/Disable process extended
            self.args.enable_process_extended = not self.args.enable_process_extended

This line is too long as per the coding-style (85/80).

            if not self.args.enable_process_extended:
                glances_processes.disable_extended()
            else:
                glances_processes.enable_extended()
        elif self.pressedkey == ord('E'):
            # 'E' > Erase the process filter
            glances_processes.process_filter = None
        elif self.pressedkey == ord('f'):
            # 'f' > Show/hide fs / folder stats
            self.args.disable_fs = not self.args.disable_fs
            self.args.disable_folders = not self.args.disable_folders
        elif self.pressedkey == ord('w'):
            # 'w' > Delete finished warning logs
            glances_events.clean()
        elif self.pressedkey == ord('x'):
            # 'x' > Delete finished warning and critical logs
            glances_events.clean(critical=True)
        elif self.pressedkey == ord('z'):
            # 'z' > Enable or disable processes
            self.args.disable_process = not self.args.disable_process
            if self.args.disable_process:
                glances_processes.disable()
            else:
                glances_processes.enable()
        elif self.pressedkey == curses.KEY_LEFT:

The variable curses does not seem to be defined in case BooleanNotNode on line 34 is False. Are you sure this can never be the case?

            # "<" (left arrow) navigation through process sort
            setattr(glances_processes, 'auto_sort', False)
            next_sort = (self.loop_position() - 1) % len(self._sort_loop)
            glances_processes.sort_key = self._sort_loop[next_sort]
        elif self.pressedkey == curses.KEY_RIGHT:
            # ">" (right arrow) navigation through process sort
            setattr(glances_processes, 'auto_sort', False)
            next_sort = (self.loop_position() + 1) % len(self._sort_loop)
            glances_processes.sort_key = self._sort_loop[next_sort]

        # Return the key code
        return self.pressedkey

    def loop_position(self):
        """Return the current sort in the loop"""
        for i, v in enumerate(self._sort_loop):

The name v does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            if v == glances_processes.sort_key:
                return i
        return 0

    def disable_top(self):
        """Disable the top panel"""
        for p in ['quicklook', 'cpu', 'gpu', 'mem', 'memswap', 'load']:

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            setattr(self.args, 'disable_' + p, True)

    def enable_top(self):
        """Enable the top panel"""
        for p in ['quicklook', 'cpu', 'gpu', 'mem', 'memswap', 'load']:

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            setattr(self.args, 'disable_' + p, False)

    def disable_fullquicklook(self):
        """Disable the full quicklook mode"""
        for p in ['quicklook', 'cpu', 'gpu', 'mem', 'memswap']:

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            setattr(self.args, 'disable_' + p, False)

    def enable_fullquicklook(self):
        """Disable the full quicklook mode"""
        self.args.disable_quicklook = False
        for p in ['cpu', 'gpu', 'mem', 'memswap']:

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            setattr(self.args, 'disable_' + p, True)

    def end(self):

This method could be written as a function/class method.

        """Shutdown the curses window."""
        if hasattr(curses, 'echo'):

The variable curses does not seem to be defined in case BooleanNotNode on line 34 is False. Are you sure this can never be the case?

            curses.echo()

The Module curses does not seem to have a member named echo.

        if hasattr(curses, 'nocbreak'):
            curses.nocbreak()

The Module curses does not seem to have a member named nocbreak.

        if hasattr(curses, 'curs_set'):
            try:
                curses.curs_set(1)

The Module curses does not seem to have a member named curs_set.

            except Exception:

Catching very general exceptions such as Exception is usually not recommended.

                pass
        curses.endwin()

The Module curses does not seem to have a member named endwin.

    def init_line_column(self):
        """Init the line and column position for the curses interface."""
        self.init_line()
        self.init_column()

    def init_line(self):
        """Init the line position for the curses interface."""
        self.line = 0

The attribute line was defined outside __init__.

        self.next_line = 0

The attribute next_line was defined outside __init__.

    def init_column(self):
        """Init the column position for the curses interface."""
        self.column = 0

The attribute column was defined outside __init__.

        self.next_column = 0

The attribute next_column was defined outside __init__.

    def new_line(self):
        """New line in the curses interface."""
        self.line = self.next_line

The attribute line was defined outside __init__.

    def new_column(self):
        """New column in the curses interface."""
        self.column = self.next_column

The attribute column was defined outside __init__.

    def __get_stat_display(self, stats, layer):

The argument layer seems to be unused.

        """Return a dict of dict with all the stats display.
        stats: Global stats dict
        layer: ~ cs_status
            "None": standalone or server mode
            "Connected": Client is connected to a Glances server
            "SNMP": Client is connected to a SNMP server
            "Disconnected": Client is disconnected from the server

        :returns: dict of dict
            * key: plugin name
            * value: dict returned by the get_stats_display Plugin method
        """
        ret = {}

        for p in stats.getPluginsList(enable=False):

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            if p == 'quicklook' or p == 'processlist':
                # processlist is done later
                # because we need to know how many processes could be displayed
                continue

            # Compute the plugin max size
            plugin_max_width = None
            if p in self._left_sidebar:
                plugin_max_width = max(self._left_sidebar_min_width,
                                       self.screen.getmaxyx()[1] - 105)
                plugin_max_width = min(self._left_sidebar_max_width,
                                       plugin_max_width)

            # Get the view
            ret[p] = stats.get_plugin(p).get_stats_display(args=self.args,
                                                           max_width=plugin_max_width)

This line is too long as per the coding-style (86/80).

        return ret

    def display(self, stats, cs_status=None):
        """Display stats on the screen.

        stats: Stats database to display
        cs_status:
            "None": standalone or server mode
            "Connected": Client is connected to a Glances server
            "SNMP": Client is connected to a SNMP server
            "Disconnected": Client is disconnected from the server

        Return:
            True if the stats have been displayed
            False if the help have been displayed
        """
        # Init the internal line/column for Glances Curses
        self.init_line_column()

        # Update the stats messages
        ###########################

        # Get all the plugins but quicklook and proceslist
        self.args.cs_status = cs_status
        __stat_display = self.__get_stat_display(stats, layer=cs_status)

        # Adapt number of processes to the available space
        max_processes_displayed = (
            self.screen.getmaxyx()[0] - 11 -
            (0 if 'docker' not in __stat_display else
                self.get_stats_display_height(__stat_display["docker"])) -

Wrong continued indentation (remove 3 spaces).

            (0 if 'processcount' not in __stat_display else
                self.get_stats_display_height(__stat_display["processcount"])) -

Wrong continued indentation (remove 3 spaces).

            (0 if 'amps' not in __stat_display else
                self.get_stats_display_height(__stat_display["amps"])) -

Wrong continued indentation (remove 3 spaces).

            (0 if 'alert' not in __stat_display else
                self.get_stats_display_height(__stat_display["alert"])))

Wrong continued indentation (remove 3 spaces).

        try:
            if self.args.enable_process_extended:
                max_processes_displayed -= 4
        except AttributeError:
            pass
        if max_processes_displayed < 0:
            max_processes_displayed = 0
        if (glances_processes.max_processes is None or
                glances_processes.max_processes != max_processes_displayed):

Wrong continued indentation (remove 4 spaces).

            logger.debug("Set number of displayed processes to {}".format(max_processes_displayed))

This line is too long as per the coding-style (99/80).

Use formatting in logging functions and pass the parameters as arguments

            glances_processes.max_processes = max_processes_displayed

        # Get the processlist
        __stat_display["processlist"] = stats.get_plugin(
            'processlist').get_stats_display(args=self.args)

        # Display the stats on the curses interface
        ###########################################

        # Help screen (on top of the other stats)
        if self.args.help_tag:
            # Display the stats...
            self.display_plugin(
                stats.get_plugin('help').get_stats_display(args=self.args))
            # ... and exit
            return False

        # =====================================
        # Display first line (system+ip+uptime)
        # Optionnaly: Cloud on second line
        # =====================================
        self.__display_header(__stat_display)

        # ==============================================================
        # Display second line (<SUMMARY>+CPU|PERCPU+<GPU>+LOAD+MEM+SWAP)
        # ==============================================================
        self.__display_top(__stat_display, stats)

        # ==================================================================
        # Display left sidebar (NETWORK+PORTS+DISKIO+FS+SENSORS+Current time)
        # ==================================================================
        self.__display_left(__stat_display)

        # ====================================
        # Display right stats (process and co)
        # ====================================
        self.__display_right(__stat_display)

        # =====================
        # Others popup messages
        # =====================

        # Display edit filter popup
        # Only in standalone mode (cs_status is None)
        if self.edit_filter and cs_status is None:
            new_filter = self.display_popup(
                'Process filter pattern: \n\n' +
                'Examples:\n' +
                '- python\n' +
                '- .*python.*\n' +
                '- /usr/lib.*\n' +
                '- name:.*nautilus.*\n' +
                '- cmdline:.*glances.*\n' +
                '- username:nicolargo\n' +
                '- username:^root        ',
                is_input=True,
                input_value=glances_processes.process_filter_input)
            glances_processes.process_filter = new_filter
        elif self.edit_filter and cs_status is not None:
            self.display_popup('Process filter only available in standalone mode')

This line is too long as per the coding-style (82/80).

        self.edit_filter = False

        # Display graph generation popup
        if self.args.generate_graph:
            self.display_popup('Generate graph in {}'.format(self.args.export_graph_path))

This line is too long as per the coding-style (90/80).

        return True

    def __display_header(self, stat_display):
        """Display the firsts lines (header) in the Curses interface.

        system + ip + uptime
        (cloud)
        """
        # First line
        self.new_line()
        self.space_between_column = 0
        l_uptime = 1
        for i in ['system', 'ip', 'uptime']:
            if i in stat_display:
                l_uptime += self.get_stats_display_width(stat_display[i])
        self.display_plugin(
            stat_display["system"],
            display_optional=(self.screen.getmaxyx()[1] >= l_uptime))
        self.space_between_column = 3
        self.new_column()
        self.display_plugin(stat_display["ip"])
        self.new_column()
        self.display_plugin(
            stat_display["uptime"],
            add_space=-(self.get_stats_display_width(stat_display["cloud"]) != 0))

This line is too long as per the coding-style (82/80).

        # Second line (optional)
        self.init_column()
        self.new_line()
        self.display_plugin(stat_display["cloud"])

    def __display_top(self, stat_display, stats):
        """Display the second line in the Curses interface.

        <QUICKLOOK> + CPU|PERCPU + <GPU> + MEM + SWAP + LOAD
        """
        self.init_column()
        self.new_line()

        # Init quicklook
        stat_display['quicklook'] = {'msgdict': []}

        # Dict for plugins width
        plugin_widths = {}
        for p in self._top:

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            plugin_widths[p] = self.get_stats_display_width(stat_display.get(p, 0)) if hasattr(self.args, 'disable_' + p) else 0

This line is too long as per the coding-style (128/80).

        # Width of all plugins
        stats_width = sum(itervalues(plugin_widths))

        # Number of plugin but quicklook
        stats_number = sum([int(stat_display[p]['msgdict'] != []) for p in self._top if not getattr(self.args, 'disable_' + p)])

This line is too long as per the coding-style (128/80).

        if not self.args.disable_quicklook:
            # Quick look is in the place !
            if self.args.full_quicklook:
                quicklook_width = self.screen.getmaxyx()[1] - (stats_width + 8 + stats_number * self.space_between_column)

This line is too long as per the coding-style (122/80).

            else:
                quicklook_width = min(self.screen.getmaxyx()[1] - (stats_width + 8 + stats_number * self.space_between_column),

This line is too long as per the coding-style (127/80).

                                      self._quicklook_max_width - 5)
            try:
                stat_display["quicklook"] = stats.get_plugin(
                    'quicklook').get_stats_display(max_width=quicklook_width, args=self.args)

This line is too long as per the coding-style (93/80).

            except AttributeError as e:

The name e does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                logger.debug("Quicklook plugin not available (%s)" % e)

Specify string format arguments as logging function parameters

            else:
                plugin_widths['quicklook'] = self.get_stats_display_width(stat_display["quicklook"])

This line is too long as per the coding-style (100/80).

                stats_width = sum(itervalues(plugin_widths)) + 1
            self.space_between_column = 1
            self.display_plugin(stat_display["quicklook"])
            self.new_column()

        # Compute spaces between plugins
        # Note: Only one space between Quicklook and others
        plugin_display_optional = {}
        for p in self._top:

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            plugin_display_optional[p] = True
        if stats_number > 1:
            self.space_between_column = max(1, int((self.screen.getmaxyx()[1] - stats_width) / (stats_number - 1)))

This line is too long as per the coding-style (115/80).

division w/o __future__ statement

            for p in ['mem', 'cpu']:

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                # No space ? Remove optional stats
                if self.space_between_column < 3:
                    plugin_display_optional[p] = False
                    plugin_widths[p] = self.get_stats_display_width(stat_display[p], without_option=True) if hasattr(self.args, 'disable_' + p) else 0

This line is too long as per the coding-style (150/80).

                    stats_width = sum(itervalues(plugin_widths)) + 1
                    self.space_between_column = max(1, int((self.screen.getmaxyx()[1] - stats_width) / (stats_number - 1)))

This line is too long as per the coding-style (123/80).

division w/o __future__ statement

        else:
            self.space_between_column = 0

        # Display CPU, MEM, SWAP and LOAD
        for p in self._top:

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            if p == 'quicklook':
                continue
            if p in stat_display:
                self.display_plugin(stat_display[p],
                                    display_optional=plugin_display_optional[p])
            if p is not 'load':
                # Skip last column
                self.new_column()

        # Space between column
        self.space_between_column = 3

        # Backup line position
        self.saved_line = self.next_line

The attribute saved_line was defined outside __init__.

    def __display_left(self, stat_display):
        """Display the left sidebar in the Curses interface."""
        self.init_column()

        if self.args.disable_left_sidebar:
            return

        for p in self._left_sidebar:

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            if ((hasattr(self.args, 'enable_' + p) or
                 hasattr(self.args, 'disable_' + p)) and p in stat_display):
                self.new_line()
                self.display_plugin(stat_display[p])

    def __display_right(self, stat_display):
        """Display the right sidebar in the Curses interface.

        docker + processcount + amps + processlist + alert
        """
        # Do not display anything if space is not available...
        if self.screen.getmaxyx()[1] < self._left_sidebar_min_width:
            return

        # Restore line position
        self.next_line = self.saved_line

The attribute next_line was defined outside __init__.

        # Display right sidebar
        self.new_column()
        for p in self._right_sidebar:

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            if ((hasattr(self.args, 'enable_' + p) or
                 hasattr(self.args, 'disable_' + p)) and p in stat_display):
                if p not in p:
                    # Catch for issue #1470
                    continue
                self.new_line()
                if p == 'processlist':
                    self.display_plugin(stat_display['processlist'],
                                        display_optional=(self.screen.getmaxyx()[1] > 102),

This line is too long as per the coding-style (91/80).

                                        display_additional=(not MACOS),
                                        max_y=(self.screen.getmaxyx()[0] - self.get_stats_display_height(stat_display['alert']) - 2))

This line is too long as per the coding-style (133/80).

                else:
                    self.display_plugin(stat_display[p])

    def display_popup(self, message,

Too many arguments (8/5)

This function exceeds the maximum number of variables (18/15).

                      size_x=None, size_y=None,
                      duration=3,
                      is_input=False,
                      input_size=30,
                      input_value=None):
        """
        Display a centered popup.

        If is_input is False:
         Display a centered popup with the given message during duration seconds
         If size_x and size_y: set the popup size
         else set it automatically
         Return True if the popup could be displayed

        If is_input is True:
         Display a centered popup with the given message and a input field
         If size_x and size_y: set the popup size
         else set it automatically
         Return the input string or None if the field is empty
        """
        # Center the popup
        sentence_list = message.split('\n')
        if size_x is None:
            size_x = len(max(sentence_list, key=len)) + 4
            # Add space for the input field
            if is_input:
                size_x += input_size
        if size_y is None:
            size_y = len(sentence_list) + 4
        screen_x = self.screen.getmaxyx()[1]
        screen_y = self.screen.getmaxyx()[0]
        if size_x > screen_x or size_y > screen_y:
            # No size to display the popup => abord
            return False
        pos_x = int((screen_x - size_x) / 2)

division w/o __future__ statement

        pos_y = int((screen_y - size_y) / 2)

division w/o __future__ statement

        # Create the popup
        popup = curses.newwin(size_y, size_x, pos_y, pos_x)

The Module curses does not seem to have a member named newwin.

The variable curses does not seem to be defined in case BooleanNotNode on line 34 is False. Are you sure this can never be the case?

        # Fill the popup
        popup.border()

        # Add the message
        for y, m in enumerate(message.split('\n')):

The name y does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name m does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            popup.addnstr(2 + y, 2, m, len(m))

        if is_input and not WINDOWS:
            # Create a subwindow for the text field
            subpop = popup.derwin(1, input_size, 2, 2 + len(m))

The loop variable m might not be defined here.

The variable m does not seem to be defined in case the for loop on line 818 is not entered. Are you sure this can never be the case?

            subpop.attron(self.colors_list['FILTER'])
            # Init the field with the current value
            if input_value is not None:
                subpop.addnstr(0, 0, input_value, len(input_value))
            # Display the popup
            popup.refresh()
            subpop.refresh()
            # Create the textbox inside the subwindows
            self.set_cursor(2)
            self.term_window.keypad(1)
            textbox = GlancesTextbox(subpop, insert_mode=False)

The variable GlancesTextbox does not seem to be defined in case BooleanNotNode on line 1057 is False. Are you sure this can never be the case?

            textbox.edit()
            self.set_cursor(0)
            self.term_window.keypad(0)
            if textbox.gather() != '':

Unnecessary "else" after "return"

                logger.debug(

Specify string format arguments as logging function parameters

                    "User enters the following string: %s" % textbox.gather())
                return textbox.gather()[:-1]
            else:
                logger.debug("User centers an empty string")
                return None
        else:
            # Display the popup
            popup.refresh()
            self.wait(duration * 1000)
            return True

    def display_plugin(self, plugin_stats,

Too many arguments (6/5)

                       display_optional=True,
                       display_additional=True,
                       max_y=65535,
                       add_space=0):
        """Display the plugin_stats on the screen.

        If display_optional=True display the optional stats
        If display_additional=True display additionnal stats
        max_y: do not display line > max_y
        add_space: add x space (line) after the plugin
        """
        # Exit if:
        # - the plugin_stats message is empty
        # - the display tag = False
        if plugin_stats is None or not plugin_stats['msgdict'] or not plugin_stats['display']:

This line is too long as per the coding-style (94/80).

            # Exit
            return 0

        # Get the screen size
        screen_x = self.screen.getmaxyx()[1]
        screen_y = self.screen.getmaxyx()[0]

        # Set the upper/left position of the message
        if plugin_stats['align'] == 'right':
            # Right align (last column)
            display_x = screen_x - self.get_stats_display_width(plugin_stats)
        else:
            display_x = self.column
        if plugin_stats['align'] == 'bottom':
            # Bottom (last line)
            display_y = screen_y - self.get_stats_display_height(plugin_stats)
        else:
            display_y = self.line

        # Display
        x = display_x

The name x does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        x_max = x
        y = display_y

The name y does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        for m in plugin_stats['msgdict']:

The name m does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            # New line
            if m['msg'].startswith('\n'):
                # Go to the next line
                y += 1

The name y does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                # Return to the first column
                x = display_x

The name x does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                continue
            # Do not display outside the screen
            if x < 0:
                continue
            if not m['splittable'] and (x + len(m['msg']) > screen_x):
                continue
            if y < 0 or (y + 1 > screen_y) or (y > max_y):
                break
            # If display_optional = False do not display optional stats
            if not display_optional and m['optional']:
                continue
            # If display_additional = False do not display additional stats
            if not display_additional and m['additional']:
                continue
            # Is it possible to display the stat with the current screen size
            # !!! Crach if not try/except... Why ???
            try:
                self.term_window.addnstr(y, x,
                                         m['msg'],
                                         # Do not disply outside the screen
                                         screen_x - x,
                                         self.colors_list[m['decoration']])
            except Exception:

Catching very general exceptions such as Exception is usually not recommended.

                pass
            else:
                # New column
                # Python 2: we need to decode to get real screen size because
                # UTF-8 special tree chars occupy several bytes.
                # Python 3: strings are strings and bytes are bytes, all is
                # good.
                try:
                    x += len(u(m['msg']))

The name x does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                except UnicodeDecodeError:
                    # Quick and dirty hack for issue #745
                    pass
                if x > x_max:
                    x_max = x

        # Compute the next Glances column/line position
        self.next_column = max(

The attribute next_column was defined outside __init__.

            self.next_column, x_max + self.space_between_column)
        self.next_line = max(self.next_line, y + self.space_between_line)

The attribute next_line was defined outside __init__.

        # Have empty lines after the plugins
        self.next_line += add_space

    def erase(self):
        """Erase the content of the screen."""
        self.term_window.erase()

    def flush(self, stats, cs_status=None):
        """Clear and update the screen.

        stats: Stats database to display
        cs_status:
            "None": standalone or server mode
            "Connected": Client is connected to the server
            "Disconnected": Client is disconnected from the server
        """
        self.erase()
        self.display(stats, cs_status=cs_status)

    def update(self,
               stats,
               duration=3,
               cs_status=None,
               return_to_browser=False):
        """Update the screen.

        INPUT
        stats: Stats database to display
        duration: duration of the loop
        cs_status:
            "None": standalone or server mode
            "Connected": Client is connected to the server
            "Disconnected": Client is disconnected from the server
        return_to_browser:
            True: Do not exist, return to the browser list
            False: Exit and return to the shell

        OUTPUT
        True: Exit key has been pressed
        False: Others cases...
        """
        # Flush display
        self.flush(stats, cs_status=cs_status)

        # If the duration is < 0 (update + export time > refresh_time)
        # Then display the interface and log a message
        if duration <= 0:
            logger.warning('Update and export time higher than refresh_time.')
            duration = 0.1

        # Wait duration (in s) time
        exitkey = False
        countdown = Timer(duration)
        # Set the default timeout (in ms) for the getch method
        self.term_window.timeout(int(duration * 1000))
        while not countdown.finished() and not exitkey:
            # Getkey
            pressedkey = self.__catch_key(return_to_browser=return_to_browser)
            # Is it an exit key ?
            exitkey = (pressedkey == ord('\x1b') or pressedkey == ord('q'))
            if not exitkey and pressedkey > -1:
                # Redraw display
                self.flush(stats, cs_status=cs_status)
                # Overwrite the timeout with the countdown
                self.term_window.timeout(int(countdown.get() * 1000))

        return exitkey

    def wait(self, delay=100):

The argument delay seems to be unused.

This method could be written as a function/class method.

        """Wait delay in ms"""
        curses.napms(100)

The Module curses does not seem to have a member named napms.

The variable curses does not seem to be defined in case BooleanNotNode on line 34 is False. Are you sure this can never be the case?

    def get_stats_display_width(self, curse_msg, without_option=False):

This method could be written as a function/class method.

        """Return the width of the formatted curses message."""
        try:
            if without_option:
                # Size without options
                c = len(max(''.join([(u(u(nativestr(i['msg'])).encode('ascii', 'replace')) if not i['optional'] else "")

This line is too long as per the coding-style (120/80).

The name c does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                                     for i in curse_msg['msgdict']]).split('\n'), key=len))

This line is too long as per the coding-style (91/80).

            else:
                # Size with all options
                c = len(max(''.join([u(u(nativestr(i['msg'])).encode('ascii', 'replace'))

This line is too long as per the coding-style (89/80).

The name c does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

                                     for i in curse_msg['msgdict']]).split('\n'), key=len))

This line is too long as per the coding-style (91/80).

        except Exception as e:

Catching very general exceptions such as Exception is usually not recommended.

The name e does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            logger.debug('ERROR: Can not compute plugin width ({})'.format(e))

Use formatting in logging functions and pass the parameters as arguments

            return 0
        else:
            return c

    def get_stats_display_height(self, curse_msg):

This method could be written as a function/class method.

        r"""Return the height of the formatted curses message.

        The height is defined by the number of '\n' (new line).
        """
        try:
            c = [i['msg'] for i in curse_msg['msgdict']].count('\n')

The name c does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        except Exception as e:

Catching very general exceptions such as Exception is usually not recommended.

The name e does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            logger.debug('ERROR: Can not compute plugin height ({})'.format(e))

Use formatting in logging functions and pass the parameters as arguments

            return 0
        else:
            return c + 1


class GlancesCursesStandalone(_GlancesCurses):

    """Class for the Glances curse standalone."""

    pass


class GlancesCursesClient(_GlancesCurses):

    """Class for the Glances curse client."""

    pass


if not WINDOWS:
    class GlancesTextbox(Textbox, object):

This class should have a docstring.

The variable Textbox does not seem to be defined in case BooleanNotNode on line 34 is False. Are you sure this can never be the case?

        def __init__(self, *args, **kwargs):

Useless super delegation in method '__init__'

            super(GlancesTextbox, self).__init__(*args, **kwargs)

The variable GlancesTextbox does not seem to be defined in case BooleanNotNode on line 1057 is False. Are you sure this can never be the case?

        def do_command(self, ch):
            if ch == 10:  # Enter
                return 0
            if ch == 127:  # Back
                return 8
            return super(GlancesTextbox, self).do_command(ch)

The variable GlancesTextbox does not seem to be defined in case BooleanNotNode on line 1057 is False. Are you sure this can never be the case?