diff --git a/jc/parsers/pyedid/LICENSE b/jc/parsers/pyedid/LICENSE new file mode 100644 index 00000000..f6616159 --- /dev/null +++ b/jc/parsers/pyedid/LICENSE @@ -0,0 +1,18 @@ +Copyright 2019-2020 Jonas Lieb, Davydov Denis + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/jc/parsers/pyedid/__init__.py b/jc/parsers/pyedid/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/jc/parsers/pyedid/edid.py b/jc/parsers/pyedid/edid.py new file mode 100755 index 00000000..fafe9c2c --- /dev/null +++ b/jc/parsers/pyedid/edid.py @@ -0,0 +1,171 @@ +""" +Edid module +""" + +import struct +from collections import namedtuple +from typing import ByteString + +__all__ = ["Edid"] + + +class Edid: + """Edid class + + Raises: + `ValueError`: if invalid edid data + """ + + _STRUCT_FORMAT = ( + "<" # little-endian + "8s" # constant header (8 bytes) + "H" # manufacturer id (2 bytes) + "H" # product id (2 bytes) + "I" # serial number (4 bytes) + "B" # manufactoring week (1 byte) + "B" # manufactoring year (1 byte) + "B" # edid version (1 byte) + "B" # edid revision (1 byte) + "B" # video input type (1 byte) + "B" # horizontal size in cm (1 byte) + "B" # vertical size in cm (1 byte) + "B" # display gamma (1 byte) + "B" # supported features (1 byte) + "10s" # color characteristics (10 bytes) + "H" # supported timings (2 bytes) + "B" # reserved timing (1 byte) + "16s" # EDID supported timings (16 bytes) + "18s" # detailed timing block 1 (18 bytes) + "18s" # detailed timing block 2 (18 bytes) + "18s" # detailed timing block 3 (18 bytes) + "18s" # detailed timing block 4 (18 bytes) + "B" # extension flag (1 byte) + "B" + ) # checksum (1 byte) + + _TIMINGS = { + 0: (1280, 1024, 75.0), + 1: (1024, 768, 75.0), + 2: (1024, 768, 70.0), + 3: (1024, 768, 60.0), + 4: (1024, 768, 87.0), + 5: (832, 624, 75.0), + 6: (800, 600, 75.0), + 7: (800, 600, 72.0), + 8: (800, 600, 60.0), + 9: (800, 600, 56.0), + 10: (640, 480, 75.0), + 11: (640, 480, 72.0), + 12: (640, 480, 67.0), + 13: (640, 480, 60.0), + 14: (720, 400, 88.0), + 15: (720, 400, 70.0), + } + + _ASPECT_RATIOS = { + 0b00: (16, 10), + 0b01: ( 4, 3), + 0b10: ( 5, 4), + 0b11: (16, 9), + } + + _RawEdid = namedtuple("RawEdid", + ("header", + "manu_id", + "prod_id", + "serial_no", + "manu_week", + "manu_year", + "edid_version", + "edid_revision", + "input_type", + "width", + "height", + "gamma", + "features", + "color", + "timings_supported", + "timings_reserved", + "timings_edid", + "timing_1", + "timing_2", + "timing_3", + "timing_4", + "extension", + "checksum") + ) + + def __init__(self, edid: ByteString): + self._parse_edid(edid) + + def _parse_edid(self, edid: ByteString): + """Convert edid byte string to edid object""" + if struct.calcsize(self._STRUCT_FORMAT) != 128: + raise ValueError("Wrong edid size.") + + if sum(map(int, edid)) % 256 != 0: + raise ValueError("Checksum mismatch.") + + unpacked = struct.unpack(self._STRUCT_FORMAT, edid) + raw_edid = self._RawEdid(*unpacked) + + if raw_edid.header != b'\x00\xff\xff\xff\xff\xff\xff\x00': + raise ValueError("Invalid header.") + + self.raw = edid + self.manufacturer_id = raw_edid.manu_id + self.product = raw_edid.prod_id + self.year = raw_edid.manu_year + 1990 + self.edid_version = "{:d}.{:d}".format(raw_edid.edid_version, raw_edid.edid_revision) + self.type = "digital" if (raw_edid.input_type & 0xFF) else "analog" + self.width = float(raw_edid.width) + self.height = float(raw_edid.height) + self.gamma = (raw_edid.gamma+100)/100 + self.dpms_standby = bool(raw_edid.features & 0xFF) + self.dpms_suspend = bool(raw_edid.features & 0x7F) + self.dpms_activeoff = bool(raw_edid.features & 0x3F) + + self.resolutions = [] + for i in range(16): + bit = raw_edid.timings_supported & (1 << i) + if bit: + self.resolutions.append(self._TIMINGS[i]) + + for i in range(8): + bytes_data = raw_edid.timings_edid[2*i:2*i+2] + if bytes_data == b'\x01\x01': + continue + byte1, byte2 = bytes_data + x_res = 8*(int(byte1)+31) + aspect_ratio = self._ASPECT_RATIOS[(byte2>>6) & 0b11] + y_res = int(x_res * aspect_ratio[1]/aspect_ratio[0]) + rate = (int(byte2) & 0b00111111) + 60.0 + self.resolutions.append((x_res, y_res, rate)) + + self.name = None + self.serial = None + + for timing_bytes in (raw_edid.timing_1, raw_edid.timing_2, raw_edid.timing_3, raw_edid.timing_4): + # "other" descriptor + if timing_bytes[0:2] == b'\x00\x00': + timing_type = timing_bytes[3] + if timing_type in (0xFF, 0xFE, 0xFC): + buffer = timing_bytes[5:] + buffer = buffer.partition(b"\x0a")[0] + text = buffer.decode("cp437") + if timing_type == 0xFF: + self.serial = text + elif timing_type == 0xFC: + self.name = text + + if not self.serial: + self.serial = raw_edid.serial_no + + def __repr__(self): + clsname = self.__class__.__name__ + attributes = [] + for name in dir(self): + if not name.startswith("_"): + value = getattr(self, name) + attributes.append("\t{}={}".format(name, value)) + return "{}(\n{}\n)".format(clsname, ", \n".join(attributes)) diff --git a/jc/parsers/pyedid/helpers/__init__.py b/jc/parsers/pyedid/helpers/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/jc/parsers/pyedid/helpers/edid_helper.py b/jc/parsers/pyedid/helpers/edid_helper.py new file mode 100644 index 00000000..b4165ca9 --- /dev/null +++ b/jc/parsers/pyedid/helpers/edid_helper.py @@ -0,0 +1,61 @@ +""" +EDID helper +""" + +from subprocess import CalledProcessError, check_output +from typing import ByteString, List + +__all__ = ["EdidHelper"] + + +class EdidHelper: + """Class for working with EDID data""" + + @staticmethod + def hex2bytes(hex_data: str) -> ByteString: + """Convert hex EDID string to bytes + + Args: + hex_data (str): hex edid string + + Returns: + ByteString: edid byte string + """ + # delete edid 1.3 additional block + if len(hex_data) > 256: + hex_data = hex_data[:256] + + numbers = [] + for i in range(0, len(hex_data), 2): + pair = hex_data[i : i + 2] + numbers.append(int(pair, 16)) + return bytes(numbers) + + @classmethod + def get_edids(cls) -> List[ByteString]: + """Get edids from xrandr + + Raises: + `RuntimeError`: if error with retrieving xrandr util data + + Returns: + List[ByteString]: list with edids + """ + try: + output = check_output(["xrandr", "--verbose"]) + except (CalledProcessError, FileNotFoundError) as err: + raise RuntimeError( + "Error retrieving xrandr util data: {}".format(err) + ) from None + + edids = [] + lines = output.splitlines() + for i, line in enumerate(lines): + line = line.decode().strip() + if line.startswith("EDID:"): + selection = lines[i + 1 : i + 9] + selection = list(s.decode().strip() for s in selection) + selection = "".join(selection) + bytes_section = cls.hex2bytes(selection) + edids.append(bytes_section) + return edids diff --git a/jc/parsers/pyedid/helpers/registry.py b/jc/parsers/pyedid/helpers/registry.py new file mode 100644 index 00000000..56ba05eb --- /dev/null +++ b/jc/parsers/pyedid/helpers/registry.py @@ -0,0 +1,136 @@ +""" +Module for working with PNP ID REGISTRY +""" + +import csv +import string +from html.parser import HTMLParser +from urllib import request + +__all__ = ["Registry"] + + +class WebPnpIdParser(HTMLParser): + """Parser pnp id from https://uefi.org/PNP_ID_List + + Examples: + p = WebPnpIdParser() + p.feed(html_data) + p.result + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._find_table = False + self._find_row = False + # first -- company name, second -- pnp id, third -- approved date + self._last_field = [] + # key -- pnp id, value -- tuple (company_name, approved_date) + self.result = {} + + def handle_starttag(self, tag, attrs): + if tag == "tbody": + self._find_table = True + elif self._find_table and tag == "tr": + self._find_row = True + + def handle_endtag(self, tag): + if tag == "tbody": + self._find_table = False + elif self._find_table and tag == "tr": + self._find_row = False + # add table row to result + self.result[self._last_field[1]] = ( + self._last_field[0], + self._last_field[-1], + ) + self._last_field.clear() + + def handle_data(self, data): + # skip processing until table is found + if not self._find_table: + return + + if self._find_row: + data = data.strip() + if data: + self._last_field.append(data) + + def error(self, message): + super().close() + + +class Registry(dict): + """Registry pnp id data dictionary + + key -- pnp_id + value -- company name + """ + + @classmethod + def from_web(cls, filter_by_id: str = None): + """Get registry from https://uefi.org/PNP_ID_List + + Args: + filter_by_id (str), optional: filter registry by id + + Raises: + + Returns: + + """ + url = "https://uefi.org/PNP_ID_List" + if filter_by_id: + url += "?search={}".format(filter_by_id) + + with request.urlopen(url) as req: + parse = WebPnpIdParser() + parse.feed(req.read().decode()) + + registry = cls() + for key, value in parse.result.items(): + # skip invalid search value + if filter_by_id and key != filter_by_id: + continue + registry[key] = value[0] + return registry + + @classmethod + def from_csv(cls, csv_path: str, filter_by_id: str = None): + """Get registry by csv local file + + Args: + csv_path (str): path to csv file + filter_by_id (str), optional: filter registry by id + + Raises: + + Returns: + + """ + registry = cls() + with open(csv_path, "r") as file: + reader = csv.reader(file) + for line in reader: + # filter + if filter_by_id and filter_by_id != line[0]: + continue + registry[line[0]] = line[1] + return registry + + def to_csv(self, csv_path: str): + """Dump registry to csv file""" + with open(csv_path, "w") as csv_file: + writer = csv.writer(csv_file) + writer.writerows(self.items()) + return self + + def get_company_from_id(self, pnp_id: str) -> str: + """Convert PNP id to company name""" + return self.get(pnp_id, "Unknown") + + def get_company_from_raw(self, raw: int) -> str: + """Convert raw edid value to company name""" + tmp = [(raw >> 10) & 31, (raw >> 5) & 31, raw & 31] + pnp_id = "".join(string.ascii_uppercase[n - 1] for n in tmp) + return self.get_company_from_id(pnp_id) diff --git a/jc/parsers/pyedid/main.py b/jc/parsers/pyedid/main.py new file mode 100644 index 00000000..4ad431f3 --- /dev/null +++ b/jc/parsers/pyedid/main.py @@ -0,0 +1,29 @@ +""" +Entrypoint +""" + +from pyedid.edid import Edid +from pyedid.helpers.edid_helper import EdidHelper +from pyedid.helpers.registry import Registry + + +def main(): + """Main func""" + + edid_csv_cache = "/tmp/pyedid-database.csv" + + try: + registry = Registry.from_csv(edid_csv_cache) + except FileNotFoundError: + print("Loading registry from web...") + registry = Registry.from_web() + print("Done!\n") + registry.to_csv(edid_csv_cache) + + for raw in EdidHelper.get_edids(): + edid = Edid(raw, registry) + print(edid) + + +if __name__ == "__main__": + main() diff --git a/jc/parsers/xrandr.py b/jc/parsers/xrandr.py index 283cf19b..0f1e364f 100644 --- a/jc/parsers/xrandr.py +++ b/jc/parsers/xrandr.py @@ -3,6 +3,7 @@ Usage (cli): $ xrandr | jc --xrandr + $ xrandr --properties | jc --xrandr or @@ -44,6 +45,9 @@ Schema: "is_connected": boolean, "is_primary": boolean, "device_name": string, + "model_name": string, + "product_id" string, + "serial_number": string, "resolution_width": integer, "resolution_height": integer, "offset_width": integer, @@ -135,10 +139,75 @@ Examples: ], "unassociated_devices": [] } + + $ xrandr --properties | jc --xrandr -p + { + "screens": [ + { + "screen_number": 0, + "minimum_width": 8, + "minimum_height": 8, + "current_width": 1920, + "current_height": 1080, + "maximum_width": 32767, + "maximum_height": 32767, + "associated_device": { + "associated_modes": [ + { + "resolution_width": 1920, + "resolution_height": 1080, + "is_high_resolution": false, + "frequencies": [ + { + "frequency": 60.03, + "is_current": true, + "is_preferred": true + }, + { + "frequency": 59.93, + "is_current": false, + "is_preferred": false + } + ] + }, + { + "resolution_width": 1680, + "resolution_height": 1050, + "is_high_resolution": false, + "frequencies": [ + { + "frequency": 59.88, + "is_current": false, + "is_preferred": false + } + ] + } + ], + "is_connected": true, + "is_primary": true, + "device_name": "eDP1", + "model_name": "ASUS VW193S", + "product_id": "54297", + "serial_number": "78L8021107", + "resolution_width": 1920, + "resolution_height": 1080, + "offset_width": 0, + "offset_height": 0, + "dimension_width": 310, + "dimension_height": 170, + "rotation": "normal", + "reflection": "normal" + } + } + ], + "unassociated_devices": [] + } """ import re from typing import Dict, List, Optional, Union import jc.utils +from jc.parsers.pyedid.edid import Edid +from jc.parsers.pyedid.helpers.edid_helper import EdidHelper class info: @@ -147,6 +216,7 @@ class info: description = "`xrandr` command parser" author = "Kevin Lyter" author_email = "lyter_git at sent.com" + details = 'Using parts of the pyedid library at https://github.com/jojonas/pyedid.' compatible = ["linux", "darwin", "cygwin", "aix", "freebsd"] magic_commands = ["xrandr"] tags = ['command'] @@ -174,10 +244,21 @@ try: "frequencies": List[Frequency], }, ) + Model = TypedDict( + "Model", + { + "name": str, + "product_id": str, + "serial_number": str, + }, + ) Device = TypedDict( "Device", { "device_name": str, + "model_name": str, + "product_id": str, + "serial_number": str, "is_connected": bool, "is_primary": bool, "resolution_width": int, @@ -294,15 +375,67 @@ def _parse_device(next_lines: List[str], quiet: bool = False) -> Optional[Device [f"{next_line} : {k} - {v} is not int-able"] ) + model: Optional[Model] = _parse_model(next_lines, quiet) + if model: + device["model_name"] = model["name"] + device["product_id"] = model["product_id"] + device["serial_number"] = model["serial_number"] + while next_lines: next_line = next_lines.pop() next_mode: Optional[Mode] = _parse_mode(next_line) if next_mode: device["associated_modes"].append(next_mode) else: + if re.match(_device_pattern, next_line): + next_lines.append(next_line) + break + return device + + +# EDID: +# 00ffffffffffff004ca3523100000000 +# 0014010380221378eac8959e57549226 +# 0f505400000001010101010101010101 +# 010101010101381d56d4500016303020 +# 250058c2100000190000000f00000000 +# 000000000025d9066a00000000fe0053 +# 414d53554e470a204ca34154000000fe +# 004c544e313536415432343430310018 +_edid_head_pattern = r"\s*EDID:\s*" +_edid_line_pattern = r"\s*(?P[0-9a-fA-F]{32})\s*" + + +def _parse_model(next_lines: List[str], quiet: bool = False) -> Optional[Model]: + if not next_lines: + return None + + next_line = next_lines.pop() + if not re.match(_edid_head_pattern, next_line): + next_lines.append(next_line) + return None + + edid_hex_value = "" + + while next_lines: + next_line = next_lines.pop() + result = re.match(_edid_line_pattern, next_line) + + if not result: next_lines.append(next_line) break - return device + + matches = result.groupdict() + edid_hex_value += matches["edid_line"] + + edid = Edid(EdidHelper.hex2bytes(edid_hex_value)) + + model: Model = { + "name": edid.name or "Generic", + "product_id": str(edid.product), + "serial_number": str(edid.serial), + } + return model # 1920x1080i 60.03*+ 59.93