Gecko [ gtgates.com ]

Name	Size	Permission	Date
Babel-2.5.1-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
Jinja2-2.10-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-05-31 13:25
PySocks-1.6.8-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
babel	[ DIR ]	drwxr-xr-x	2024-02-12 23:58
backports	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
beautifulsoup4-4.6.3-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
boto	[ DIR ]	drwxr-xr-x	2024-02-12 23:58
boto-2.49.0.dist-info	[ DIR ]	drwxr-xr-x	2021-10-01 08:10
bs4	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
chardet	[ DIR ]	drwxr-xr-x	2024-02-12 23:58
chardet-3.0.4-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
clcommon	[ DIR ]	drwxr-xr-x	2024-02-12 23:58
click	[ DIR ]	drwxr-xr-x	2020-12-20 03:43
click-7.1.2.dist-info	[ DIR ]	drwxr-xr-x	2020-12-20 03:43
cpanel_shared_backups_agent-2.1.30.dist-info	[ DIR ]	drwxr-xr-x	2023-10-21 18:57
cssselect	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
cssselect-0.9.2-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
distro-1.2.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2020-12-20 02:57
filechunkio	[ DIR ]	drwxr-xr-x	2021-10-02 02:45
filechunkio-1.8-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2021-10-02 02:45
google	[ DIR ]	drwxr-xr-x	2025-10-21 13:29
hw_cpbackup	[ DIR ]	drwxr-xr-x	2023-10-21 18:57
idna	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
idna-2.5-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
ipaddress-1.0.18-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:51
ipaddress-1.0.23.dist-info	[ DIR ]	drwxr-xr-x	2020-12-20 03:07
jinja2	[ DIR ]	drwxr-xr-x	2024-05-31 13:25
leapp	[ DIR ]	drwxr-xr-x	2024-02-13 00:19
pathlib2	[ DIR ]	drwxr-xr-x	2021-10-01 08:10
pathlib2-2.3.6.dist-info	[ DIR ]	drwxr-xr-x	2021-10-01 08:10
pip	[ DIR ]	drwxr-xr-x	2024-02-12 23:51
pip-20.3.4.dist-info	[ DIR ]	drwxr-xr-x	2021-01-30 08:57
pip-9.0.3.dist-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:51
pip_tools-5.5.0.dist-info	[ DIR ]	drwxr-xr-x	2021-01-02 08:30
piptools	[ DIR ]	drwxr-xr-x	2021-01-02 08:30
pkg_resources	[ DIR ]	drwxr-xr-x	2024-05-31 13:25
protobuf-3.5.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2025-10-27 13:27
py_dmidecode-0.1.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2020-12-20 03:07
pycriu	[ DIR ]	drwxr-xr-x	2024-02-12 23:54
python_magic-0.4.18.dist-info	[ DIR ]	drwxr-xr-x	2020-12-20 07:35
pytz	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
pytz-2017.2-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
requests	[ DIR ]	drwxr-xr-x	2024-02-12 23:58
requests-2.20.0-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:52
setuptools	[ DIR ]	drwxr-xr-x	2024-05-31 13:25
setuptools-39.0.1.dist-info	[ DIR ]	drwxr-xr-x	2024-05-31 13:25
six-1.11.0.dist-info	[ DIR ]	drwxr-xr-x	2024-02-12 23:51
six-1.15.0.dist-info	[ DIR ]	drwxr-xr-x	2020-12-20 03:43
test	[ DIR ]	drwxr-xr-x	2023-10-21 18:57
urllib3	[ DIR ]	drwxr-xr-x	2024-05-31 13:25
urllib3-1.24.2-py2.7.egg-info	[ DIR ]	drwxr-xr-x	2024-05-31 13:25
backports.ssl_match_hostname-3.5.0.1-py2.7.egg-info	3.96 KB	-rw-r--r--	2022-04-21 13:59
crit-0.0.1-py2.7.egg-info	231 B	-rw-r--r--	2022-09-12 06:34
distro.py	38.54 KB	-rw-r--r--	2017-12-24 16:29
distro.pyc	35.54 KB	-rw-r--r--	2019-04-24 14:58
distro.pyo	35.44 KB	-rw-r--r--	2019-04-24 14:58
dmidecode.py	6.94 KB	-rw-r--r--	2019-10-10 06:43
dmidecode.pyc	7.22 KB	-rw-r--r--	2020-12-20 03:07
easy-install.pth	209 B	-rw-r--r--	2017-06-28 14:58
easy_install.py	126 B	-rw-r--r--	2024-04-10 05:04
easy_install.pyc	315 B	-rw-r--r--	2024-04-10 05:04
easy_install.pyo	315 B	-rw-r--r--	2024-04-10 05:04
ipaddress.py	78.28 KB	-rw-r--r--	2017-01-11 12:29
ipaddress.pyc	74.04 KB	-rw-r--r--	2022-04-21 15:05
ipaddress.pyo	73.86 KB	-rw-r--r--	2022-04-21 15:05
protobuf-3.5.0-py2.7-nspkg.pth	539 B	-rw-r--r--	2025-10-21 13:29
pyzor-1.0.0-py2.7.egg	78.18 KB	-rw-r--r--	2017-06-28 14:58
six.py	30.16 KB	-rw-r--r--	2022-04-21 16:04
six.pyc	30.05 KB	-rw-r--r--	2022-04-21 16:04
six.pyo	30.05 KB	-rw-r--r--	2022-04-21 16:04
socks.py	31.52 KB	-rw-r--r--	2017-12-21 04:05
socks.pyc	26.54 KB	-rw-r--r--	2022-04-21 16:16
socks.pyo	26.54 KB	-rw-r--r--	2022-04-21 16:16
sockshandler.py	2.84 KB	-rw-r--r--	2017-12-21 04:05
sockshandler.pyc	4.45 KB	-rw-r--r--	2022-04-21 16:16
sockshandler.pyo	4.45 KB	-rw-r--r--	2022-04-21 16:16

Rename

import re
import subprocess

class DMIParse:
    """
    dmidecode information parsing object
    requires dmidecode output as input string
    """

def __init__(self, str, default="n/a"):
        self.default = default
        self.data = self.dmidecode_parse(str)

def get(self, type_id):
        if isinstance(type_id, str):
            for type_num, type_str in self.type2str.items():
                if type_str == type_id:
                    type_id = type_num

result = list()
        for entry in self.data.values():
            if entry["DMIType"] == type_id:
                result.append(entry)
        return result

def manufacturer(self):
        return self.get("System")[0].get("Manufacturer", self.default)

def model(self):
        return self.get("System")[0].get("Product Name", self.default)

def serial_number(self):
        return self.get("System")[0].get("Serial Number", self.default)

def cpu_type(self):
        cpu_version = self.default
        for cpu in self.get("Processor"):
            if cpu.get("Core Enabled"):
                cpu_version = cpu.get("Version", self.default)
        return cpu_version

def cpu_num(self):
        cpus = 0
        for cpu in self.get("Processor"):
            if cpu.get("Core Enabled"):
                cpus += 1
        return cpus

def total_enabled_cores(self):
        cores = 0
        for cpu in self.get("Processor"):
            cores += int(cpu.get("Core Enabled", 0))
        return cores

def total_ram(self):
        """Returns total memory in GB"""
        return sum([self.size_to_gb(slot["Size"]) for slot in self.get("Memory Device")])

def firmware(self):
        return self.get("BIOS")[0].get("Firmware Revision", self.default)

handle_re = re.compile("^Handle\\s+(.+),\\s+DMI\\s+type\\s+(\\d+),\\s+(\\d+)\\s+bytes$")
    in_block_re = re.compile("^\\t\\t(.+)$")
    record_re = re.compile("\\t(.+):\\s+(.+)$")
    record2_re = re.compile("\\t(.+):$")

type2str = {
        0: "BIOS",
        1: "System",
        2: "Baseboard",
        3: "Chassis",
        4: "Processor",
        5: "Memory Controller",
        6: "Memory Module",
        7: "Cache",
        8: "Port Connector",
        9: "System Slots",
        10: "On Board Devices",
        11: "OEM Strings",
        12: "System Configuration Options",
        13: "BIOS Language",
        14: "Group Associations",
        15: "System Event Log",
        16: "Physical Memory Array",
        17: "Memory Device",
        18: "32-bit Memory Error",
        19: "Memory Array Mapped Address",
        20: "Memory Device Mapped Address",
        21: "Built-in Pointing Device",
        22: "Portable Battery",
        23: "System Reset",
        24: "Hardware Security",
        25: "System Power Controls",
        26: "Voltage Probe",
        27: "Cooling Device",
        28: "Temperature Probe",
        29: "Electrical Current Probe",
        30: "Out-of-band Remote Access",
        31: "Boot Integrity Services",
        32: "System Boot",
        33: "64-bit Memory Error",
        34: "Management Device",
        35: "Management Device Component",
        36: "Management Device Threshold Data",
        37: "Memory Channel",
        38: "IPMI Device",
        39: "Power Supply",
        40: "Additional Information",
        41: "Onboard Devices Extended Information",
        42: "Management Controller Host Interface",
    }

def dmidecode_parse(self, buffer):  # noqa: C901
        data = {}
        #  Each record is separated by double newlines
        split_output = buffer.split("\n\n")

for record in split_output:
            record_element = record.splitlines()

#  Entries with less than 3 lines are incomplete / inactive
            #  skip them
            if len(record_element) < 3:
                continue

handle_data = DMIDecode.handle_re.findall(record_element[0])

if not handle_data:
                continue
            handle_data = handle_data[0]

dmi_handle = handle_data[0]

data[dmi_handle] = {}
            data[dmi_handle]["DMIType"] = int(handle_data[1])
            data[dmi_handle]["DMISize"] = int(handle_data[2])

#  Okay, we know 2nd line == name
            data[dmi_handle]["DMIName"] = record_element[1]

in_block_elemet = ""
            in_block_list = ""

#  Loop over the rest of the record, gathering values
            for i in range(2, len(record_element), 1):
                if i >= len(record_element):
                    break
                #  Check whether we are inside a \t\t block
                if in_block_elemet != "":

in_block_data = DMIDecode.in_block_re.findall(record_element[1])

if in_block_data:
                        if not in_block_list:
                            in_block_list = in_block_data[0][0]
                        else:
                            in_block_list = in_block_list + "\t\t"
                            +in_block_data[0][1]

data[dmi_handle][in_block_elemet] = in_block_list
                        continue
                    else:
                        # We are out of the \t\t block; reset it again, and let
                        # the parsing continue
                        in_block_elemet = ""

record_data = DMIDecode.record_re.findall(record_element[i])

#  Is this the line containing handle identifier, type, size?
                if record_data:
                    data[dmi_handle][record_data[0][0]] = record_data[0][1]
                    continue

#  Didn't findall regular entry, maybe an array of data?
                record_data2 = DMIDecode.record2_re.findall(record_element[i])

if record_data2:
                    #  This is an array of data - let the loop know we are
                    #  inside an array block
                    in_block_elemet = record_data2[0][0]
                    continue
        return data

def size_to_gb(self, str):
        """Convert dmidecode memory size description to GB"""
        nb = re.search("[0-9]+", str)
        if nb:
            nb = int(re.search("[0-9]+", str).group())
        else:
            return 0
        if "MB" in str:
            return nb / 1024 if nb else 0
        elif "GB" in str:
            return nb
        else:
            return 0

class DMIDecode(DMIParse):
    """Wrapper over DMIParse which runs dmidecode locally"""

def __init__(self, command="dmidecode"):
        self.dmidecode = command
        raw = self._run()
        super().__init__(raw)

def _run(self):
        # let subprocess merge stderr with stdout
        proc = subprocess.Popen(self.dmidecode, stderr=subprocess.STDOUT, stdout=subprocess.PIPE)
        stdout, stderr = proc.communicate()
        if proc.returncode > 0:
            raise RuntimeError("{} failed with an error:\n{}".format(self.dmidecode, stdout.decode()))
        else:
            return stdout.decode()