glances.globals.iteritems() - Code Metrics - Inspection of "Glances version 4.0.0" - nicolargo/glances - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( ee826a...d9056e )

by Nicolas

created 2024-05-12 08:45 UTC

glances.globals.iteritems() A

↳ Parent: glances.globals

Complexity

Conditions

Size

Total Lines	2
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nop	1
dl	0
loc	2
rs	10
c	0
b	0
f	0

# -*- coding: utf-8 -*-
#
# This file is part of Glances.
#
# SPDX-FileCopyrightText: 2024 Nicolas Hennion <[email protected]>
#
# SPDX-License-Identifier: LGPL-3.0-only
#

"""Common objects shared by all Glances modules."""

################
# GLOBAL IMPORTS
################

import errno
import os
import sys
import platform
import ujson
from operator import itemgetter, methodcaller
import unicodedata
import types
import subprocess
from datetime import datetime
import re
import base64
import functools
import weakref

import queue
from configparser import ConfigParser, NoOptionError, NoSectionError
from statistics import mean
from xmlrpc.client import Fault, ProtocolError, ServerProxy, Transport, Server
from xmlrpc.server import SimpleXMLRPCRequestHandler, SimpleXMLRPCServer
from urllib.request import urlopen, Request
from urllib.error import HTTPError, URLError
from urllib.parse import urlparse

# Correct issue #1025 by monkey path the xmlrpc lib
from defusedxml.xmlrpc import monkey_patch

monkey_patch()

##############
# GLOBALS VARS
##############

# OS constants (some libraries/features are OS-dependent)
BSD = sys.platform.find('bsd') != -1
LINUX = sys.platform.startswith('linux')
MACOS = sys.platform.startswith('darwin')
SUNOS = sys.platform.startswith('sunos')
WINDOWS = sys.platform.startswith('win')
WSL = "linux" in platform.system().lower() and "microsoft" in platform.uname()[3].lower()

# Set the AMPs, plugins and export modules path
work_path = os.path.realpath(os.path.dirname(__file__))
amps_path = os.path.realpath(os.path.join(work_path, 'amps'))
plugins_path = os.path.realpath(os.path.join(work_path, 'plugins'))
exports_path = os.path.realpath(os.path.join(work_path, 'exports'))
sys_path = sys.path[:]
sys.path.insert(1, exports_path)
sys.path.insert(1, plugins_path)
sys.path.insert(1, amps_path)

# Types
text_type = str
binary_type = bytes
bool_type = bool
long = int

# Alias errors
PermissionError = OSError

# Alias methods
viewkeys = methodcaller('keys')
viewvalues = methodcaller('values')
viewitems = methodcaller('items')


###################
# GLOBALS FUNCTIONS
###################


def printandflush(string):
    """Print and flush (used by stdout* outputs modules)"""
    print(string, flush=True)


def to_ascii(s):
    """Convert the bytes string to a ASCII string
    Usefull to remove accent (diacritics)"""
    if isinstance(s, binary_type):
        return s.decode()
    return s.encode('ascii', 'ignore').decode()


def listitems(d):
    return list(d.items())


def listkeys(d):
    return list(d.keys())


def listvalues(d):
    return list(d.values())


def iteritems(d):
    return iter(d.items())


def iterkeys(d):
    return iter(d.keys())


def itervalues(d):
    return iter(d.values())


def u(s, errors='replace'):
    if isinstance(s, text_type):
        return s
    return s.decode('utf-8', errors=errors)


def b(s, errors='replace'):
    if isinstance(s, binary_type):
        return s
    return s.encode('utf-8', errors=errors)


def nativestr(s, errors='replace'):
    if isinstance(s, text_type):
        return s
    elif isinstance(s, (int, float)):
        return s.__str__()
    else:
        return s.decode('utf-8', errors=errors)


def system_exec(command):
    """Execute a system command and return the result as a str"""
    try:
        res = subprocess.run(command.split(' '), stdout=subprocess.PIPE).stdout.decode('utf-8')
    except Exception as e:
        res = 'ERROR: {}'.format(e)
    return res.rstrip()


def subsample(data, sampling):
    """Compute a simple mean subsampling.

    Data should be a list of numerical itervalues

    Return a subsampled list of sampling lenght
    """
    if len(data) <= sampling:
        return data
    sampling_length = int(round(len(data) / float(sampling)))
    return [mean(data[s * sampling_length : (s + 1) * sampling_length]) for s in range(0, sampling)]


def time_serie_subsample(data, sampling):
    """Compute a simple mean subsampling.

    Data should be a list of set (time, value)

    Return a subsampled list of sampling length
    """
    if len(data) <= sampling:
        return data
    t = [t[0] for t in data]
    v = [t[1] for t in data]
    sampling_length = int(round(len(data) / float(sampling)))
    t_subsampled = [t[s * sampling_length : (s + 1) * sampling_length][0] for s in range(0, sampling)]
    v_subsampled = [mean(v[s * sampling_length : (s + 1) * sampling_length]) for s in range(0, sampling)]
    return list(zip(t_subsampled, v_subsampled))


def to_fahrenheit(celsius):
    """Convert Celsius to Fahrenheit."""
    return celsius * 1.8 + 32


def is_admin():
    """
    https://stackoverflow.com/a/19719292
    @return: True if the current user is an 'Admin' whatever that
    means (root on Unix), otherwise False.
    Warning: The inner function fails unless you have Windows XP SP2 or
    higher. The failure causes a traceback to be printed and this
    function to return False.
    """

    if os.name == 'nt':
        import ctypes
        import traceback

        # WARNING: requires Windows XP SP2 or higher!
        try:
            return ctypes.windll.shell32.IsUserAnAdmin()
        except Exception as e:
            print("Admin check failed with error: %s" % e)
            traceback.print_exc()
            return False
    else:
        # Check for root on Posix
        return os.getuid() == 0


def key_exist_value_not_none(k, d):
    # Return True if:
    # - key k exists
    # - d[k] is not None
    return k in d and d[k] is not None


def key_exist_value_not_none_not_v(k, d, value='', lengh=None):
    # Return True if:
    # - key k exists
    # - d[k] is not None
    # - d[k] != value
    # - if lengh is not None and len(d[k]) >= lengh
    return k in d and d[k] is not None and d[k] != value and (lengh is None or len(d[k]) >= lengh)


def disable(class_name, var):
    """Set disable_<var> to True in the class class_name."""
    setattr(class_name, 'enable_' + var, False)
    setattr(class_name, 'disable_' + var, True)


def enable(class_name, var):
    """Set disable_<var> to False in the class class_name."""
    setattr(class_name, 'enable_' + var, True)
    setattr(class_name, 'disable_' + var, False)


def safe_makedirs(path):
    """A safe function for creating a directory tree."""
    try:
        os.makedirs(path)
    except OSError as err:
        if err.errno == errno.EEXIST:
            if not os.path.isdir(path):
                raise
        else:
            raise


def pretty_date(time=False):
    """
    Get a datetime object or a int() Epoch timestamp and return a
    pretty string like 'an hour ago', 'Yesterday', '3 months ago',
    'just now', etc
    Source: https://stackoverflow.com/questions/1551382/user-friendly-time-format-in-python
    """
    now = datetime.now()
    if isinstance(time, int):
        diff = now - datetime.fromtimestamp(time)
    elif isinstance(time, datetime):
        diff = now - time
    elif not time:
        diff = 0
    second_diff = diff.seconds

    day_diff = diff.days

    if day_diff < 0:
        return ''

    if day_diff == 0:
        if second_diff < 10:
            return "just now"
        if second_diff < 60:
            return str(second_diff) + " secs"
        if second_diff < 120:
            return "a min"
        if second_diff < 3600:
            return str(second_diff // 60) + " mins"
        if second_diff < 7200:
            return "an hour"
        if second_diff < 86400:
            return str(second_diff // 3600) + " hours"
    if day_diff == 1:
        return "yesterday"
    if day_diff < 7:
        return str(day_diff) + " days"
    if day_diff < 31:
        return str(day_diff // 7) + " weeks"
    if day_diff < 365:
        return str(day_diff // 30) + " months"
    return str(day_diff // 365) + " years"


def urlopen_auth(url, username, password):
    """Open a url with basic auth"""
    return urlopen(
        Request(
            url,
            headers={'Authorization': 'Basic ' + base64.b64encode(('%s:%s' % (username, password)).encode()).decode()},
        )
    )


def json_dumps(data):
    """Return the object data in a JSON format.

    Manage the issue #815 for Windows OS with UnicodeDecodeError catching.
    """
    try:
        return ujson.dumps(data)
    except UnicodeDecodeError:
        return ujson.dumps(data, ensure_ascii=False)


def dictlist(data, item):
    if isinstance(data, dict):
        try:
            return {item: data[item]}
        except (TypeError, IndexError, KeyError):
            return None
    elif isinstance(data, list):
        try:
            # Source:
            # http://stackoverflow.com/questions/4573875/python-get-index-of-dictionary-item-in-list
            # But https://github.com/nicolargo/glances/issues/1401
            return {item: list(map(itemgetter(item), data))}
        except (TypeError, IndexError, KeyError):
            return None
    else:
        return None


def json_dumps_dictlist(data, item):
    dl = dictlist(data, item)
    if dl is None:
        return None
    else:
        return json_dumps(dl)


def string_value_to_float(s):
    """Convert a string with a value and an unit to a float.
    Example:
    '12.5 MB' -> 12500000.0
    '32.5 GB' -> 32500000000.0
    Args:
        s (string): Input string with value and unit
    Output:
        float: The value in float
    """
    convert_dict = {
        None: 1,
        'B': 1,
        'KB': 1000,
        'MB': 1000000,
        'GB': 1000000000,
        'TB': 1000000000000,
        'PB': 1000000000000000,
    }
    unpack_string = [
        i[0] if i[1] == '' else i[1].upper() for i in re.findall(r'([\d.]+)|([^\d.]+)', s.replace(' ', ''))
    ]
    if len(unpack_string) == 2:
        value, unit = unpack_string
    elif len(unpack_string) == 1:
        value = unpack_string[0]
        unit = None
    else:
        return None
    try:
        value = float(unpack_string[0])
    except ValueError:
        return None
    return value * convert_dict[unit]


def file_exists(filename):
    """Return True if the file exists and is readable."""
    return os.path.isfile(filename) and os.access(filename, os.R_OK)


def folder_size(path, errno=0):
    """Return a tuple with the size of the directory given by path and the errno.
    If an error occurs (for example one file or subfolder is not accessible),
    errno is set to the error number.

    path: <string>
    errno: <int> Should always be 0 when calling the function"""
    ret_size = 0
    ret_err = errno
    try:
        for f in os.scandir(path):
            if f.is_dir(follow_symlinks=False) and (f.name != '.' or f.name != '..'):
                ret = folder_size(os.path.join(path, f.name), ret_err)
                ret_size += ret[0]
                ret_err = ret[1]
            else:
                try:
                    ret_size += f.stat().st_size
                except OSError as e:
                    ret_err = e.errno
    except (OSError, PermissionError) as e:
        return 0, e.errno
    else:
        return ret_size, ret_err


def weak_lru_cache(maxsize=128, typed=False):
    """LRU Cache decorator that keeps a weak reference to self
    Source: https://stackoverflow.com/a/55990799"""

    def wrapper(func):
        @functools.lru_cache(maxsize, typed)
        def _func(_self, *args, **kwargs):
            return func(_self(), *args, **kwargs)

        @functools.wraps(func)
        def inner(self, *args, **kwargs):
            return _func(weakref.ref(self), *args, **kwargs)

        return inner

    return wrapper


def namedtuple_to_dict(data):
    """Convert a namedtuple to a dict, using the _asdict() method embeded in PsUtil stats."""
    return {k: (v._asdict() if hasattr(v, '_asdict') else v) for k, v in data.items()}


def list_of_namedtuple_to_list_of_dict(data):
    """Convert a list of namedtuples to a dict, using the _asdict() method embeded in PsUtil stats."""
    return [namedtuple_to_dict(d) for d in data]


def replace_special_chars(input_string, by=' '):
    """Replace some special char by another in the input_string
    Return: the string with the chars replaced"""
    return input_string.replace('\r\n', by).replace('\n', by).replace('\t', by)


1			# -- coding: utf-8 --
2			#
3			# This file is part of Glances.
4			#
5			# SPDX-FileCopyrightText: 2024 Nicolas Hennion <[email protected]>
6			#
7			# SPDX-License-Identifier: LGPL-3.0-only
8			#
9
10			"""Common objects shared by all Glances modules."""
11
12			################
13			# GLOBAL IMPORTS
14			################
15
16			import errno
17			import os
18			import sys
19			import platform
20			import ujson
21			from operator import itemgetter, methodcaller
22			import unicodedata
23			import types
24			import subprocess
25			from datetime import datetime
26			import re
27			import base64
28			import functools
29			import weakref
30
31			import queue
32			from configparser import ConfigParser, NoOptionError, NoSectionError
33			from statistics import mean
34			from xmlrpc.client import Fault, ProtocolError, ServerProxy, Transport, Server
35			from xmlrpc.server import SimpleXMLRPCRequestHandler, SimpleXMLRPCServer
36			from urllib.request import urlopen, Request
37			from urllib.error import HTTPError, URLError
38			from urllib.parse import urlparse
39
40			# Correct issue #1025 by monkey path the xmlrpc lib
41			from defusedxml.xmlrpc import monkey_patch
42
43			monkey_patch()
44
45			##############
46			# GLOBALS VARS
47			##############
48
49			# OS constants (some libraries/features are OS-dependent)
50			BSD = sys.platform.find('bsd') != -1
51			LINUX = sys.platform.startswith('linux')
52			MACOS = sys.platform.startswith('darwin')
53			SUNOS = sys.platform.startswith('sunos')
54			WINDOWS = sys.platform.startswith('win')
55			WSL = "linux" in platform.system().lower() and "microsoft" in platform.uname()[3].lower()
56
57			# Set the AMPs, plugins and export modules path
58			work_path = os.path.realpath(os.path.dirname(__file__))
59			amps_path = os.path.realpath(os.path.join(work_path, 'amps'))
60			plugins_path = os.path.realpath(os.path.join(work_path, 'plugins'))
61			exports_path = os.path.realpath(os.path.join(work_path, 'exports'))
62			sys_path = sys.path[:]
63			sys.path.insert(1, exports_path)
64			sys.path.insert(1, plugins_path)
65			sys.path.insert(1, amps_path)
66
67			# Types
68			text_type = str
69			binary_type = bytes
70			bool_type = bool
71			long = int
72
73			# Alias errors
74			PermissionError = OSError
75
76			# Alias methods
77			viewkeys = methodcaller('keys')
78			viewvalues = methodcaller('values')
79			viewitems = methodcaller('items')
80
81
82			###################
83			# GLOBALS FUNCTIONS
84			###################
85
86
87			def printandflush(string):
88			"""Print and flush (used by stdout* outputs modules)"""
89			print(string, flush=True)
90
91
92			def to_ascii(s):
93			"""Convert the bytes string to a ASCII string
94			Usefull to remove accent (diacritics)"""
95			if isinstance(s, binary_type):
96			return s.decode()
97			return s.encode('ascii', 'ignore').decode()
98
99
100			def listitems(d):
101			return list(d.items())
102
103
104			def listkeys(d):
105			return list(d.keys())
106
107
108			def listvalues(d):
109			return list(d.values())
110
111
112			def iteritems(d):
113			return iter(d.items())
114
115
116			def iterkeys(d):
117			return iter(d.keys())
118
119
120			def itervalues(d):
121			return iter(d.values())
122
123
124			def u(s, errors='replace'):
125			if isinstance(s, text_type):
126			return s
127			return s.decode('utf-8', errors=errors)
128
129
130			def b(s, errors='replace'):
131			if isinstance(s, binary_type):
132			return s
133			return s.encode('utf-8', errors=errors)
134
135
136			def nativestr(s, errors='replace'):
137			if isinstance(s, text_type):
138			return s
139			elif isinstance(s, (int, float)):
140			return s.__str__()
141			else:
142			return s.decode('utf-8', errors=errors)
143
144
145			def system_exec(command):
146			"""Execute a system command and return the result as a str"""
147			try:
148			res = subprocess.run(command.split(' '), stdout=subprocess.PIPE).stdout.decode('utf-8')
149			except Exception as e:
150			res = 'ERROR: {}'.format(e)
151			return res.rstrip()
152
153
154			def subsample(data, sampling):
155			"""Compute a simple mean subsampling.
156
157			Data should be a list of numerical itervalues
158
159			Return a subsampled list of sampling lenght
160			"""
161			if len(data) <= sampling:
162			return data
163			sampling_length = int(round(len(data) / float(sampling)))
164			return [mean(data[s * sampling_length : (s + 1) * sampling_length]) for s in range(0, sampling)]
165
166
167			def time_serie_subsample(data, sampling):
168			"""Compute a simple mean subsampling.
169
170			Data should be a list of set (time, value)
171
172			Return a subsampled list of sampling length
173			"""
174			if len(data) <= sampling:
175			return data
176			t = [t[0] for t in data]
177			v = [t[1] for t in data]
178			sampling_length = int(round(len(data) / float(sampling)))
179			t_subsampled = [t[s * sampling_length : (s + 1) * sampling_length][0] for s in range(0, sampling)]
180			v_subsampled = [mean(v[s * sampling_length : (s + 1) * sampling_length]) for s in range(0, sampling)]
181			return list(zip(t_subsampled, v_subsampled))
182
183
184			def to_fahrenheit(celsius):
185			"""Convert Celsius to Fahrenheit."""
186			return celsius * 1.8 + 32
187
188
189			def is_admin():
190			"""
191			https://stackoverflow.com/a/19719292
192			@return: True if the current user is an 'Admin' whatever that
193			means (root on Unix), otherwise False.
194			Warning: The inner function fails unless you have Windows XP SP2 or
195			higher. The failure causes a traceback to be printed and this
196			function to return False.
197			"""
198
199			if os.name == 'nt':
200			import ctypes
201			import traceback
202
203			# WARNING: requires Windows XP SP2 or higher!
204			try:
205			return ctypes.windll.shell32.IsUserAnAdmin()
206			except Exception as e:
207			print("Admin check failed with error: %s" % e)
208			traceback.print_exc()
209			return False
210			else:
211			# Check for root on Posix
212			return os.getuid() == 0
213
214
215			def key_exist_value_not_none(k, d):
216			# Return True if:
217			# - key k exists
218			# - d[k] is not None
219			return k in d and d[k] is not None
220
221
222			def key_exist_value_not_none_not_v(k, d, value='', lengh=None):
223			# Return True if:
224			# - key k exists
225			# - d[k] is not None
226			# - d[k] != value
227			# - if lengh is not None and len(d[k]) >= lengh
228			return k in d and d[k] is not None and d[k] != value and (lengh is None or len(d[k]) >= lengh)
229
230
231			def disable(class_name, var):
232			"""Set disable_<var> to True in the class class_name."""
233			setattr(class_name, 'enable_' + var, False)
234			setattr(class_name, 'disable_' + var, True)
235
236
237			def enable(class_name, var):
238			"""Set disable_<var> to False in the class class_name."""
239			setattr(class_name, 'enable_' + var, True)
240			setattr(class_name, 'disable_' + var, False)
241
242
243			def safe_makedirs(path):
244			"""A safe function for creating a directory tree."""
245			try:
246			os.makedirs(path)
247			except OSError as err:
248			if err.errno == errno.EEXIST:
249			if not os.path.isdir(path):
250			raise
251			else:
252			raise
253
254
255			def pretty_date(time=False):
256			"""
257			Get a datetime object or a int() Epoch timestamp and return a
258			pretty string like 'an hour ago', 'Yesterday', '3 months ago',
259			'just now', etc
260			Source: https://stackoverflow.com/questions/1551382/user-friendly-time-format-in-python
261			"""
262			now = datetime.now()
263			if isinstance(time, int):
264			diff = now - datetime.fromtimestamp(time)
265			elif isinstance(time, datetime):
266			diff = now - time
267			elif not time:
268			diff = 0
269			second_diff = diff.seconds
			0 ignored issues – show introduced 2022-03-05 13:41 UTC by Report Bug Copy Issue Report The variable `diff` does not seem to be defined for all execution paths. Loading history...
270			day_diff = diff.days
271
272			if day_diff < 0:
273			return ''
274
275			if day_diff == 0:
276			if second_diff < 10:
277			return "just now"
278			if second_diff < 60:
279			return str(second_diff) + " secs"
280			if second_diff < 120:
281			return "a min"
282			if second_diff < 3600:
283			return str(second_diff // 60) + " mins"
284			if second_diff < 7200:
285			return "an hour"
286			if second_diff < 86400:
287			return str(second_diff // 3600) + " hours"
288			if day_diff == 1:
289			return "yesterday"
290			if day_diff < 7:
291			return str(day_diff) + " days"
292			if day_diff < 31:
293			return str(day_diff // 7) + " weeks"
294			if day_diff < 365:
295			return str(day_diff // 30) + " months"
296			return str(day_diff // 365) + " years"
297
298
299			def urlopen_auth(url, username, password):
300			"""Open a url with basic auth"""
301			return urlopen(
302			Request(
303			url,
304			headers={'Authorization': 'Basic ' + base64.b64encode(('%s:%s' % (username, password)).encode()).decode()},
305			)
306			)
307
308
309			def json_dumps(data):
310			"""Return the object data in a JSON format.
311
312			Manage the issue #815 for Windows OS with UnicodeDecodeError catching.
313			"""
314			try:
315			return ujson.dumps(data)
316			except UnicodeDecodeError:
317			return ujson.dumps(data, ensure_ascii=False)
318
319
320			def dictlist(data, item):
321			if isinstance(data, dict):
322			try:
323			return {item: data[item]}
324			except (TypeError, IndexError, KeyError):
325			return None
326			elif isinstance(data, list):
327			try:
328			# Source:
329			# http://stackoverflow.com/questions/4573875/python-get-index-of-dictionary-item-in-list
330			# But https://github.com/nicolargo/glances/issues/1401
331			return {item: list(map(itemgetter(item), data))}
332			except (TypeError, IndexError, KeyError):
333			return None
334			else:
335			return None
336
337
338			def json_dumps_dictlist(data, item):
339			dl = dictlist(data, item)
340			if dl is None:
341			return None
342			else:
343			return json_dumps(dl)
344
345
346			def string_value_to_float(s):
347			"""Convert a string with a value and an unit to a float.
348			Example:
349			'12.5 MB' -> 12500000.0
350			'32.5 GB' -> 32500000000.0
351			Args:
352			s (string): Input string with value and unit
353			Output:
354			float: The value in float
355			"""
356			convert_dict = {
357			None: 1,
358			'B': 1,
359			'KB': 1000,
360			'MB': 1000000,
361			'GB': 1000000000,
362			'TB': 1000000000000,
363			'PB': 1000000000000000,
364			}
365			unpack_string = [
366			i[0] if i[1] == '' else i[1].upper() for i in re.findall(r'([\d.]+)\|([^\d.]+)', s.replace(' ', ''))
367			]
368			if len(unpack_string) == 2:
369			value, unit = unpack_string
370			elif len(unpack_string) == 1:
371			value = unpack_string[0]
372			unit = None
373			else:
374			return None
375			try:
376			value = float(unpack_string[0])
377			except ValueError:
378			return None
379			return value * convert_dict[unit]
380
381
382			def file_exists(filename):
383			"""Return True if the file exists and is readable."""
384			return os.path.isfile(filename) and os.access(filename, os.R_OK)
385
386
387			def folder_size(path, errno=0):
388			"""Return a tuple with the size of the directory given by path and the errno.
389			If an error occurs (for example one file or subfolder is not accessible),
390			errno is set to the error number.
391
392			path: <string>
393			errno: <int> Should always be 0 when calling the function"""
394			ret_size = 0
395			ret_err = errno
396			try:
397			for f in os.scandir(path):
398			if f.is_dir(follow_symlinks=False) and (f.name != '.' or f.name != '..'):
399			ret = folder_size(os.path.join(path, f.name), ret_err)
400			ret_size += ret[0]
401			ret_err = ret[1]
402			else:
403			try:
404			ret_size += f.stat().st_size
405			except OSError as e:
406			ret_err = e.errno
407			except (OSError, PermissionError) as e:
408			return 0, e.errno
409			else:
410			return ret_size, ret_err
411
412
413			def weak_lru_cache(maxsize=128, typed=False):
414			"""LRU Cache decorator that keeps a weak reference to self
415			Source: https://stackoverflow.com/a/55990799"""
416
417			def wrapper(func):
418			@functools.lru_cache(maxsize, typed)
419			def _func(_self, args, *kwargs):
420			return func(_self(), args, *kwargs)
421
422			@functools.wraps(func)
423			def inner(self, args, *kwargs):
424			return _func(weakref.ref(self), args, *kwargs)
425
426			return inner
427
428			return wrapper
429
430
431			def namedtuple_to_dict(data):
432			"""Convert a namedtuple to a dict, using the _asdict() method embeded in PsUtil stats."""
433			return {k: (v._asdict() if hasattr(v, '_asdict') else v) for k, v in data.items()}
434
435
436			def list_of_namedtuple_to_list_of_dict(data):
437			"""Convert a list of namedtuples to a dict, using the _asdict() method embeded in PsUtil stats."""
438			return [namedtuple_to_dict(d) for d in data]
439
440
441			def replace_special_chars(input_string, by=' '):
442			"""Replace some special char by another in the input_string
443			Return: the string with the chars replaced"""
444			return input_string.replace('\r\n', by).replace('\n', by).replace('\t', by)
445

nicolargo / glances

Push — master ( ee826a...d9056e )

glances.globals.iteritems() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like