Metadata-Version: 2.4
Name: dmiparser
Version: 6.0
Summary: This parse dmidecode output to JSON text
Home-page: https://github.com/Arondight/python-dmiparser
Download-URL: https://github.com/Arondight/python-dmiparser/tags
Author: Qin Fandong
Author-email: shell_way@foxmail.com
License: MIT License
Platform: Any
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Requires-Python: >=3.6
Description-Content-Type: text/markdown
License-File: LICENSE
Dynamic: download-url
Dynamic: license-file

# python-dmiparser

## About

This parse `dmidecode` output to JSON text.

## Installation

### PyPI

```shell
pip3 install -U dmiparser
```

### RPM

```shell
git clone https://github.com/Arondight/python-dmiparser.git
cd ./python-dmiparser/
python3 ./setup.py bdist --format=rpm
sudo dnf install ./dist/dmiparser-*.noarch.rpm
```

> Tip: Requires the `rpm-build` package in your Linux distribution.

## Usage

### Python 3 script

#### DmiParser

This accepts a `str` (with the output of `dmidecode`) as argument and converts it to JSON text.

```python
#!/usr/bin/env python3
import json
from dmiparser import DmiParser
from functools import partial


def report(*args: str) -> None:
    """report texts with format

    @param args: text string
    """
    br = lambda e: print("-" * e)
    brn = partial(br, 80)

    brn()

    for e in args:
        print(e)
        brn()


if "__main__" == __name__:
    text = (
        "# dmidecode 3.6\n"
        "Getting SMBIOS data from sysfs.\n"
        "SMBIOS 3.7.0 present.\n"
        "\n"
        "Handle 0x0000, DMI type 0, 26 bytes\n"
        "Platform Firmware Information\n"
        "\tVendor: American Megatrends International, LLC.\n"
        "\tVersion: 3A09.QCT001\n"
        "\tRelease Date: 11/14/2024\n"
        "\tAddress: 0xF0000\n"
        "\tRuntime Size: 64 KiB\n"
        "\tROM Size: 64 MiB\n"
        "\tCharacteristics:\n"
        "\t\tPCI is supported\n"
        "\t\tFirmware is upgradeable\n"
        "\t\tFirmware shadowing is allowed\n"
        "\t\tBoot from CD is supported\n"
        "\t\tSelectable boot is supported\n"
        "\t\tFirmware ROM is socketed\n"
        "\t\tEDD is supported\n"
        "\t\tACPI is supported\n"
        "\t\tBIOS boot specification is supported\n"
        "\t\tTargeted content distribution is supported\n"
        "\t\tUEFI is supported\n"
        "\tPlatform Firmware Revision: 5.35\n"
        "\tEmbedded Controller Firmware Revision: 3.9\n"
        "\n"
    )

    # parser = DmiParser(text)
    parser = DmiParser(text, sort_keys=True, indent=2)

    parsedStr = str(parser)  # get str
    parsedObj = json.loads(str(parser))  # get object

    report(parsedStr, parsedObj)
```

#### DmiDecoder (the default wrapper)

This run `dmidecode` and converting the output of the command to JSON text.

```python
from dmiparser.dmidecoder import DmiDecoder
from functools import partial


def report(*args: str) -> None:
    """report texts with format

    @param args: text string
    """
    br = lambda e: print("-" * e)
    brn = partial(br, 80)

    brn()

    for e in args:
        print(e)
        brn()


def getCpuInfo(dmidecoder) -> str:
    """Get CPU information, will return text like below.

    CPU_0:
        Family: Xeon
        Version: Intel(R) Xeon(R) 6767P
        Voltage: 1.8 V
        Speed: 2400 MHz/3900 MHz
        Status: Populated, Enabled
        Core: 64/64
        Thread: 128
    CPU_1:
        Family: Xeon
        Version: Intel(R) Xeon(R) 6767P
        Voltage: 1.8 V
        Speed: 2400 MHz/3900 MHz
        Status: Populated, Enabled
        Core: 64/64
        Thread: 128

    @param dmidecoder: DmiDecoder object
    @return: text of CPU information
    """
    text = ""

    for sid, name in dmidecoder.sections:
        def getFirst(*args):
            vals = dmidecoder.getProp(*args, id=sid, name=name)
            return vals[0] if len(vals) > 0 else None

        text += "{}:\n".format(getFirst("Socket Designation"))
        text += "\tFamily: {}\n".format(getFirst("Family"))
        text += "\tVersion: {}\n".format(getFirst("Version"))
        text += "\tVoltage: {}\n".format(getFirst("Voltage"))
        text += "\tSpeed: {}/{}\n".format(getFirst("Current Speed"), getFirst("Max Speed"))
        text += "\tStatus: {}\n".format(getFirst("Status"))
        text += "\tCore: {}/{}\n".format(getFirst("Core Enabled"), getFirst("Core Count"))
        text += "\tThread: {}\n".format(getFirst("Thread Count"))

    return text


if "__main__" == __name__:
    # dmidecoder = DmiDecoder()
    dmidecoder4 = DmiDecoder("-t 4", sort_keys=True, indent=2)  # Type 4 is Processor

    report(dmidecoder4.text, str(dmidecoder4.data), getCpuInfo(dmidecoder4))
```

> Tip: Superuser permissions are required here to run `dmidecode`.

### Executable command

#### dmiparser

This read output of `dmidecode` from pipe and print it as JSON text.

```shell
sudo dmidecode | dmiparser
sudo dmidecode -t 4 | dmiparser --format
```

```shell
sudo dmidecode >/tmp/dmidecode.txt
dmiparser </tmp/dmidecode.txt
```

> Tip: you can run `dmiparser` module as a script (use `python3 -m dmiparser` instead of `dmiparser` command).

#### dmidecoder

This run `dmidecode` and print the output as JSON text.

```shell
sudo dmidecoder
sudo dmidecoder --arguments "-t 4" --format
```

> Tip: you can run `dmiparser.dmidecoder` module as a script (use `python3 -m dmiparser.dmidecoder` instead
> of `dmidecoder` command).

## Development

### Test

```shell
tox
```

### Format

```shell
black -l 120 ./dmiparser/ ./tests/
```

## License

[MIT LICENSE](https://github.com/Arondight/python-dmiparser/blob/master/LICENSE).
