diff --git a/.ruff-excludes.toml b/.ruff-excludes.toml index 06ac9c38e6316a..ac26af8b3c8a5e 100644 --- a/.ruff-excludes.toml +++ b/.ruff-excludes.toml @@ -439,7 +439,6 @@ "E701", # https://docs.astral.sh/ruff/rules/multiple-statements-on-one-line-colon "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports "SIM201", # https://docs.astral.sh/ruff/rules/negate-equal-op - "UP006", # https://docs.astral.sh/ruff/rules/non-pep585-annotation "UP007", # https://docs.astral.sh/ruff/rules/non-pep604-annotation "UP032", # https://docs.astral.sh/ruff/rules/f-string "UP035", # https://docs.astral.sh/ruff/rules/deprecated-import @@ -452,7 +451,6 @@ "I001", # https://docs.astral.sh/ruff/rules/unsorted-imports "SIM102", # https://docs.astral.sh/ruff/rules/collapsible-if "SIM118", # https://docs.astral.sh/ruff/rules/in-dict-keys - "UP006", # https://docs.astral.sh/ruff/rules/non-pep585-annotation "UP007", # https://docs.astral.sh/ruff/rules/non-pep604-annotation "UP015", # https://docs.astral.sh/ruff/rules/redundant-open-modes "UP032", # https://docs.astral.sh/ruff/rules/f-string diff --git a/scripts/dts/python-devicetree/src/devicetree/dtlib.py b/scripts/dts/python-devicetree/src/devicetree/dtlib.py index 000c80148874ee..cf1d80a9c498f2 100644 --- a/scripts/dts/python-devicetree/src/devicetree/dtlib.py +++ b/scripts/dts/python-devicetree/src/devicetree/dtlib.py @@ -20,9 +20,9 @@ import string import sys import textwrap -from typing import (Any, Dict, Iterable, List, +from typing import (Any, Iterable, NamedTuple, NoReturn, Optional, - Set, Tuple, TYPE_CHECKING, Union) + TYPE_CHECKING, Union) # NOTE: tests/test_dtlib.py is the test suite for this library. @@ -92,9 +92,9 @@ def __init__(self, name: str, parent: Optional['Node'], dt: 'DT'): # Remember to update DT.__deepcopy__() if you change this. self._name = name - self.props: Dict[str, 'Property'] = {} - self.nodes: Dict[str, 'Node'] = {} - self.labels: List[str] = [] + self.props: dict[str, Property] = {} + self.nodes: dict[str, Node] = {} + self.labels: list[str] = [] self.parent = parent self.dt = dt @@ -309,13 +309,13 @@ def __init__(self, node: Node, name: str): self.name = name self.value = b"" - self.labels: List[str] = [] + self.labels: list[str] = [] # We have to wait to set this until later, when we've got # the entire tree. - self.offset_labels: Dict[str, int] = {} + self.offset_labels: dict[str, int] = {} self.node: Node = node - self._label_offset_lst: List[Tuple[str, int]] = [] + self._label_offset_lst: list[tuple[str, int]] = [] # A list of [offset, label, type] lists (sorted by offset), # giving the locations of references within the value. 'type' @@ -323,7 +323,7 @@ def __init__(self, node: Node, name: str): # _MarkerType.PHANDLE, for a phandle reference, or # _MarkerType.LABEL, for a label on/within data. Node paths # and phandles need to be patched in after parsing. - self._markers: List[List] = [] + self._markers: list[list] = [] @property def type(self) -> Type: @@ -388,7 +388,7 @@ def to_num(self, signed=False) -> int: return int.from_bytes(self.value, "big", signed=signed) - def to_nums(self, signed=False) -> List[int]: + def to_nums(self, signed=False) -> list[int]: """ Returns the value of the property as a list of numbers. @@ -455,7 +455,7 @@ def to_string(self) -> str: return ret # The separate 'return' appeases the type checker. - def to_strings(self) -> List[str]: + def to_strings(self) -> list[str]: """ Returns the value of the property as a list of strings. @@ -498,7 +498,7 @@ def to_node(self) -> Node: return self.node.dt.phandle2node[int.from_bytes(self.value, "big")] - def to_nodes(self) -> List[Node]: + def to_nodes(self) -> list[Node]: """ Returns a list with the Nodes the phandles in the property point to. @@ -761,12 +761,12 @@ def __init__(self, filename: Optional[str], include_path: Iterable[str] = (), # Remember to update __deepcopy__() if you change this. self._root: Optional[Node] = None - self.alias2node: Dict[str, Node] = {} - self.label2node: Dict[str, Node] = {} - self.label2prop: Dict[str, Property] = {} - self.label2prop_offset: Dict[str, Tuple[Property, int]] = {} - self.phandle2node: Dict[int, Node] = {} - self.memreserves: List[Tuple[Set[str], int, int]] = [] + self.alias2node: dict[str, Node] = {} + self.label2node: dict[str, Node] = {} + self.label2prop: dict[str, Property] = {} + self.label2prop_offset: dict[str, tuple[Property, int]] = {} + self.phandle2node: dict[int, Node] = {} + self.memreserves: list[tuple[set[str], int, int]] = [] self.filename = filename self._force = force @@ -774,7 +774,7 @@ def __init__(self, filename: Optional[str], include_path: Iterable[str] = (), if filename is not None: self._parse_file(filename, include_path) else: - self._include_path: List[str] = [] + self._include_path: list[str] = [] @property def root(self) -> Node: @@ -1027,7 +1027,7 @@ def _parse_file(self, filename: str, include_path: Iterable[str]): self._file_contents = f.read() self._tok_i = self._tok_end_i = 0 - self._filestack: List[_FileStackElt] = [] + self._filestack: list[_FileStackElt] = [] self._lexer_state: int = _DEFAULT self._saved_token: Optional[_Token] = None @@ -2027,7 +2027,7 @@ def to_num(data: bytes, length: Optional[int] = None, return int.from_bytes(data, "big", signed=signed) -def to_nums(data: bytes, length: int = 4, signed: bool = False) -> List[int]: +def to_nums(data: bytes, length: int = 4, signed: bool = False) -> list[int]: """ Like Property.to_nums(), but takes an arbitrary 'bytes' array. The values are assumed to be in big-endian format, which is standard in devicetree. diff --git a/scripts/dts/python-devicetree/src/devicetree/edtlib.py b/scripts/dts/python-devicetree/src/devicetree/edtlib.py index 854b2698a2dc36..752e15dc81d4e0 100644 --- a/scripts/dts/python-devicetree/src/devicetree/edtlib.py +++ b/scripts/dts/python-devicetree/src/devicetree/edtlib.py @@ -70,8 +70,8 @@ from collections import defaultdict from copy import deepcopy from dataclasses import dataclass -from typing import (Any, Callable, Dict, Iterable, List, NoReturn, - Optional, Set, TYPE_CHECKING, Tuple, Union) +from typing import (Any, Callable, Iterable, NoReturn, + Optional, TYPE_CHECKING, Union) import logging import os import re @@ -161,7 +161,7 @@ class Binding: are multiple levels of 'child-binding' descriptions in the binding. """ - def __init__(self, path: Optional[str], fname2path: Dict[str, str], + def __init__(self, path: Optional[str], fname2path: dict[str, str], raw: Any = None, require_compatible: bool = True, require_description: bool = True): """ @@ -193,7 +193,7 @@ def __init__(self, path: Optional[str], fname2path: Dict[str, str], if it is present in the binding. """ self.path: Optional[str] = path - self._fname2path: Dict[str, str] = fname2path + self._fname2path: dict[str, str] = fname2path if raw is None: if path is None: @@ -225,10 +225,10 @@ def __init__(self, path: Optional[str], fname2path: Dict[str, str], self._check(require_compatible, require_description) # Initialize look up tables. - self.prop2specs: Dict[str, 'PropertySpec'] = {} + self.prop2specs: dict[str, 'PropertySpec'] = {} for prop_name in self.raw.get("properties", {}).keys(): self.prop2specs[prop_name] = PropertySpec(prop_name, self) - self.specifier2cells: Dict[str, List[str]] = {} + self.specifier2cells: dict[str, list[str]] = {} for key, val in self.raw.items(): if key.endswith("-cells"): self.specifier2cells[key[:-len("-cells")]] = val @@ -252,12 +252,12 @@ def compatible(self) -> Optional[str]: return self.raw.get('compatible') @property - def bus(self) -> Union[None, str, List[str]]: + def bus(self) -> Union[None, str, list[str]]: "See the class docstring" return self.raw.get('bus') @property - def buses(self) -> List[str]: + def buses(self) -> list[str]: "See the class docstring" if self.raw.get('bus') is not None: return self._buses @@ -287,7 +287,7 @@ def _merge_includes(self, raw: dict, binding_path: Optional[str]) -> dict: # file has a 'required:' for a particular property, OR the values # together, so that 'required: true' wins. - merged: Dict[str, Any] = {} + merged: dict[str, Any] = {} if isinstance(include, str): # Simple scalar string case @@ -530,7 +530,7 @@ class PropertySpec: def __init__(self, name: str, binding: Binding): self.binding: Binding = binding self.name: str = name - self._raw: Dict[str, Any] = self.binding.raw["properties"][name] + self._raw: dict[str, Any] = self.binding.raw["properties"][name] def __repr__(self) -> str: return f"" @@ -586,12 +586,12 @@ def enum_upper_tokenizable(self) -> bool: return self._enum_upper_tokenizable @property - def const(self) -> Union[None, int, List[int], str, List[str]]: + def const(self) -> Union[None, int, list[int], str, list[str]]: "See the class docstring" return self._raw.get("const") @property - def default(self) -> Union[None, int, List[int], str, List[str]]: + def default(self) -> Union[None, int, list[int], str, list[str]]: "See the class docstring" return self._raw.get("default") @@ -611,9 +611,9 @@ def specifier_space(self) -> Optional[str]: return self._raw.get("specifier-space") PropertyValType = Union[int, str, - List[int], List[str], - 'Node', List['Node'], - List[Optional['ControllerAndData']], + list[int], list[str], + 'Node', list['Node'], + list[Optional['ControllerAndData']], bytes, None] @@ -697,7 +697,7 @@ def type(self) -> str: return self.spec.type @property - def val_as_tokens(self) -> List[str]: + def val_as_tokens(self) -> list[str]: "See the class docstring" ret = [] for subval in self.val if isinstance(self.val, list) else [self.val]: @@ -706,7 +706,7 @@ def val_as_tokens(self) -> List[str]: return ret @property - def enum_indices(self) -> Optional[List[int]]: + def enum_indices(self) -> Optional[list[int]]: "See the class docstring" enum = self.spec.enum val = self.val if isinstance(self.val, list) else [self.val] @@ -848,7 +848,7 @@ class PinCtrl: node: 'Node' name: Optional[str] - conf_nodes: List['Node'] + conf_nodes: list['Node'] @property def name_as_token(self): @@ -1020,12 +1020,12 @@ def __init__( # Public, some of which are initialized properly later: self.edt: 'EDT' = edt self.dep_ordinal: int = -1 - self.compats: List[str] = compats - self.ranges: List[Range] = [] - self.regs: List[Register] = [] - self.props: Dict[str, Property] = {} - self.interrupts: List[ControllerAndData] = [] - self.pinctrls: List[PinCtrl] = [] + self.compats: list[str] = compats + self.ranges: list[Range] = [] + self.regs: list[Register] = [] + self.props: dict[str, Property] = {} + self.interrupts: list[ControllerAndData] = [] + self.pinctrls: list[PinCtrl] = [] self.bus_node = self._bus_node(support_fixed_partitions_on_any_bus) self._init_binding() @@ -1074,7 +1074,7 @@ def label(self) -> Optional[str]: return None @property - def labels(self) -> List[str]: + def labels(self) -> list[str]: "See the class docstring" return self._node.labels @@ -1084,7 +1084,7 @@ def parent(self) -> Optional['Node']: return self.edt._node2enode.get(self._node.parent) # type: ignore @property - def children(self) -> Dict[str, 'Node']: + def children(self) -> dict[str, 'Node']: "See the class docstring" # Could be initialized statically too to preserve identity, but not # sure if needed. Parent nodes being initialized before their children @@ -1101,7 +1101,7 @@ def child_index(self, node) -> int: # method is callable to handle parents needing to be # initialized before their chidlren. By the time we # return from __init__, 'self.children' is callable. - self._child2index: Dict[str, int] = {} + self._child2index: dict[str, int] = {} for index, child_path in enumerate(child.path for child in self.children.values()): self._child2index[child_path] = index @@ -1109,12 +1109,12 @@ def child_index(self, node) -> int: return self._child2index[node.path] @property - def required_by(self) -> List['Node']: + def required_by(self) -> list['Node']: "See the class docstring" return self.edt._graph.required_by(self) @property - def depends_on(self) -> List['Node']: + def depends_on(self) -> list['Node']: "See the class docstring" return self.edt._graph.depends_on(self) @@ -1153,20 +1153,20 @@ def binding_path(self) -> Optional[str]: return None @property - def aliases(self) -> List[str]: + def aliases(self) -> list[str]: "See the class docstring" return [alias for alias, node in self._node.dt.alias2node.items() if node is self._node] @property - def buses(self) -> List[str]: + def buses(self) -> list[str]: "See the class docstring" if self._binding: return self._binding.buses return [] @property - def on_buses(self) -> List[str]: + def on_buses(self) -> list[str]: "See the class docstring" bus_node = self.bus_node return bus_node.buses if bus_node else [] @@ -1225,7 +1225,7 @@ def spi_cs_gpio(self) -> Optional[ControllerAndData]: return ret @property - def gpio_hogs(self) -> List[ControllerAndData]: + def gpio_hogs(self) -> list[ControllerAndData]: "See the class docstring" if "gpio-hog" not in self.props: @@ -1327,12 +1327,12 @@ def _binding_from_properties(self) -> None: _err(f"compatible in node with inferred binding: {self.path}") # Synthesize a 'raw' binding as if it had been parsed from YAML. - raw: Dict[str, Any] = { + raw: dict[str, Any] = { 'description': 'Inferred binding from properties, via edtlib.', 'properties': {}, } for name, prop in self._node.props.items(): - pp: Dict[str, str] = {} + pp: dict[str, str] = {} if prop.type == Type.EMPTY: pp["type"] = "boolean" elif prop.type == Type.BYTES: @@ -1750,7 +1750,7 @@ def _standard_phandle_val_list( self, prop: dtlib_Property, specifier_space: Optional[str] - ) -> List[Optional[ControllerAndData]]: + ) -> list[Optional[ControllerAndData]]: # Parses a property like # # = ; @@ -1800,7 +1800,7 @@ def _standard_phandle_val_list( # if there is no specifier space in _check_prop_by_type(). specifier_space = prop.name[:-1] - res: List[Optional[ControllerAndData]] = [] + res: list[Optional[ControllerAndData]] = [] for item in _phandle_val_list(prop, specifier_space): if item is None: @@ -1829,7 +1829,7 @@ def _named_cells( controller: 'Node', data: bytes, basename: str - ) -> Dict[str, int]: + ) -> dict[str, int]: # Returns a dictionary that maps -cells names given in the # binding for 'controller' to cell values. 'data' is the raw data, as a # byte array. @@ -1839,7 +1839,7 @@ def _named_cells( f"for {self._node!r} lacks binding") if basename in controller._binding.specifier2cells: - cell_names: List[str] = controller._binding.specifier2cells[basename] + cell_names: list[str] = controller._binding.specifier2cells[basename] else: # Treat no *-cells in the binding the same as an empty *-cells, so # that bindings don't have to have e.g. an empty 'clock-cells:' for @@ -1923,12 +1923,12 @@ class EDT: def __init__(self, dts: Optional[str], - bindings_dirs: List[str], + bindings_dirs: list[str], warn_reg_unit_address_mismatch: bool = True, default_prop_types: bool = True, support_fixed_partitions_on_any_bus: bool = True, infer_binding_for_paths: Optional[Iterable[str]] = None, - vendor_prefixes: Optional[Dict[str, str]] = None, + vendor_prefixes: Optional[dict[str, str]] = None, werror: bool = False): """EDT constructor. @@ -1977,34 +1977,34 @@ def __init__(self, # and update the tests for that method. # Public attributes (the rest are properties) - self.nodes: List[Node] = [] - self.compat2nodes: Dict[str, List[Node]] = defaultdict(list) - self.compat2okay: Dict[str, List[Node]] = defaultdict(list) - self.compat2notokay: Dict[str, List[Node]] = defaultdict(list) - self.compat2vendor: Dict[str, str] = defaultdict(str) - self.compat2model: Dict[str, str] = defaultdict(str) - self.label2node: Dict[str, Node] = {} - self.dep_ord2node: Dict[int, Node] = {} + self.nodes: list[Node] = [] + self.compat2nodes: dict[str, list[Node]] = defaultdict(list) + self.compat2okay: dict[str, list[Node]] = defaultdict(list) + self.compat2notokay: dict[str, list[Node]] = defaultdict(list) + self.compat2vendor: dict[str, str] = defaultdict(str) + self.compat2model: dict[str, str] = defaultdict(str) + self.label2node: dict[str, Node] = {} + self.dep_ord2node: dict[int, Node] = {} self.dts_path: str = dts # type: ignore - self.bindings_dirs: List[str] = list(bindings_dirs) + self.bindings_dirs: list[str] = list(bindings_dirs) # Saved kwarg values for internal use self._warn_reg_unit_address_mismatch: bool = warn_reg_unit_address_mismatch self._default_prop_types: bool = default_prop_types self._fixed_partitions_no_bus: bool = support_fixed_partitions_on_any_bus - self._infer_binding_for_paths: Set[str] = set(infer_binding_for_paths or []) - self._vendor_prefixes: Dict[str, str] = vendor_prefixes or {} + self._infer_binding_for_paths: set[str] = set(infer_binding_for_paths or []) + self._vendor_prefixes: dict[str, str] = vendor_prefixes or {} self._werror: bool = bool(werror) # Other internal state - self._compat2binding: Dict[Tuple[str, Optional[str]], Binding] = {} + self._compat2binding: dict[tuple[str, Optional[str]], Binding] = {} self._graph: Graph = Graph() - self._binding_paths: List[str] = _binding_paths(self.bindings_dirs) - self._binding_fname2path: Dict[str, str] = { + self._binding_paths: list[str] = _binding_paths(self.bindings_dirs) + self._binding_fname2path: dict[str, str] = { os.path.basename(path): path for path in self._binding_paths } - self._node2enode: Dict[dtlib_Node, Node] = {} + self._node2enode: dict[dtlib_Node, Node] = {} if dts is not None: try: @@ -2036,8 +2036,8 @@ def get_node(self, path: str) -> Node: _err(e) @property - def chosen_nodes(self) -> Dict[str, Node]: - ret: Dict[str, Node] = {} + def chosen_nodes(self) -> dict[str, Node]: + ret: dict[str, Node] = {} try: chosen = self._dt.get_node("/chosen") @@ -2092,7 +2092,7 @@ def __deepcopy__(self, memo) -> 'EDT': return ret @property - def scc_order(self) -> List[List[Node]]: + def scc_order(self) -> list[list[Node]]: try: return self._graph.scc_order() except Exception as e: @@ -2227,7 +2227,7 @@ def _init_compat2binding(self) -> None: def _binding(self, raw: Optional[dict], binding_path: str, - dt_compats: Set[str]) -> Optional[Binding]: + dt_compats: set[str]) -> Optional[Binding]: # Convert a 'raw' binding from YAML to a Binding object and return it. # # Error out if the raw data looks like an invalid binding. @@ -2387,8 +2387,8 @@ def _check(self) -> None: assert isinstance(compat, str) -def bindings_from_paths(yaml_paths: List[str], - ignore_errors: bool = False) -> List[Binding]: +def bindings_from_paths(yaml_paths: list[str], + ignore_errors: bool = False) -> list[Binding]: """ Get a list of Binding objects from the yaml files 'yaml_paths'. @@ -2417,11 +2417,11 @@ class EDTError(Exception): # -def load_vendor_prefixes_txt(vendor_prefixes: str) -> Dict[str, str]: +def load_vendor_prefixes_txt(vendor_prefixes: str) -> dict[str, str]: """Load a vendor-prefixes.txt file and return a dict representation mapping a vendor prefix to the vendor name. """ - vnd2vendor: Dict[str, str] = {} + vnd2vendor: dict[str, str] = {} with open(vendor_prefixes, 'r', encoding='utf-8') as f: for line in f: line = line.strip() @@ -2443,7 +2443,7 @@ def load_vendor_prefixes_txt(vendor_prefixes: str) -> Dict[str, str]: # -def _dt_compats(dt: DT) -> Set[str]: +def _dt_compats(dt: DT) -> set[str]: # Returns a set() with all 'compatible' strings in the devicetree # represented by dt (a dtlib.DT instance) @@ -2453,7 +2453,7 @@ def _dt_compats(dt: DT) -> Set[str]: for compat in node.props["compatible"].to_strings()} -def _binding_paths(bindings_dirs: List[str]) -> List[str]: +def _binding_paths(bindings_dirs: list[str]) -> list[str]: # Returns a list with the paths to all bindings (.yaml files) in # 'bindings_dirs' @@ -2475,8 +2475,8 @@ def _binding_inc_error(msg): def _check_include_dict(name: Optional[str], - allowlist: Optional[List[str]], - blocklist: Optional[List[str]], + allowlist: Optional[list[str]], + blocklist: Optional[list[str]], child_filter: Optional[dict], binding_path: Optional[str]) -> None: # Check that an 'include:' named 'name' with property-allowlist @@ -2494,9 +2494,9 @@ def _check_include_dict(name: Optional[str], while child_filter is not None: child_copy = deepcopy(child_filter) - child_allowlist: Optional[List[str]] = ( + child_allowlist: Optional[list[str]] = ( child_copy.pop('property-allowlist', None)) - child_blocklist: Optional[List[str]] = ( + child_blocklist: Optional[list[str]] = ( child_copy.pop('property-blocklist', None)) next_child_filter: Optional[dict] = ( child_copy.pop('child-binding', None)) @@ -2516,8 +2516,8 @@ def _check_include_dict(name: Optional[str], def _filter_properties(raw: dict, - allowlist: Optional[List[str]], - blocklist: Optional[List[str]], + allowlist: Optional[list[str]], + blocklist: Optional[list[str]], child_filter: Optional[dict], binding_path: Optional[str]) -> None: # Destructively modifies 'raw["properties"]' and @@ -2538,8 +2538,8 @@ def _filter_properties(raw: dict, def _filter_properties_helper(props: Optional[dict], - allowlist: Optional[List[str]], - blocklist: Optional[List[str]], + allowlist: Optional[list[str]], + blocklist: Optional[list[str]], binding_path: Optional[str]) -> None: if props is None or (allowlist is None and blocklist is None): return @@ -2560,7 +2560,7 @@ def _filter_properties_helper(props: Optional[dict], del props[prop] -def _check_prop_filter(name: str, value: Optional[List[str]], +def _check_prop_filter(name: str, value: Optional[list[str]], binding_path: Optional[str]) -> None: # Ensure an include: ... property-allowlist or property-blocklist # is a list. @@ -2832,7 +2832,7 @@ def _interrupt_parent(start_node: dtlib_Node) -> dtlib_Node: f"nor any of its parents has an 'interrupt-parent' property") -def _interrupts(node: dtlib_Node) -> List[Tuple[dtlib_Node, bytes]]: +def _interrupts(node: dtlib_Node) -> list[tuple[dtlib_Node, bytes]]: # Returns a list of (, ) tuples, with one tuple per # interrupt generated by 'node'. is the destination of the # interrupt (possibly after mapping through an 'interrupt-map'), and @@ -2842,7 +2842,7 @@ def _interrupts(node: dtlib_Node) -> List[Tuple[dtlib_Node, bytes]]: if "interrupts-extended" in node.props: prop = node.props["interrupts-extended"] - ret: List[Tuple[dtlib_Node, bytes]] = [] + ret: list[tuple[dtlib_Node, bytes]] = [] for entry in _phandle_val_list(prop, "interrupt"): if entry is None: _err(f"node '{node.path}' interrupts-extended property " @@ -2869,7 +2869,7 @@ def _map_interrupt( child: dtlib_Node, parent: dtlib_Node, child_spec: bytes -) -> Tuple[dtlib_Node, bytes]: +) -> tuple[dtlib_Node, bytes]: # Translates an interrupt headed from 'child' to 'parent' with data # 'child_spec' through any 'interrupt-map' properties. Returns a # (, ) tuple with the final destination after mapping. @@ -2906,7 +2906,7 @@ def _map_phandle_array_entry( parent: dtlib_Node, child_spec: bytes, basename: str -) -> Tuple[dtlib_Node, bytes]: +) -> tuple[dtlib_Node, bytes]: # Returns a (, ) tuple with the final destination after # mapping through any '-map' (e.g. gpio-map) properties. See # _map_interrupt(). @@ -2930,7 +2930,7 @@ def _map( child_spec: bytes, spec_len_fn: Callable[[dtlib_Node], int], require_controller: bool -) -> Tuple[dtlib_Node, bytes]: +) -> tuple[dtlib_Node, bytes]: # Common code for mapping through -map properties, e.g. # interrupt-map and gpio-map. # @@ -3105,7 +3105,7 @@ def _not(b: bytes) -> bytes: def _phandle_val_list( prop: dtlib_Property, n_cells_name: str -) -> List[Optional[Tuple[dtlib_Node, bytes]]]: +) -> list[Optional[tuple[dtlib_Node, bytes]]]: # Parses a ' ...' value. The number of # cells that make up each is derived from the node pointed at by # the preceding . @@ -3123,7 +3123,7 @@ def _phandle_val_list( full_n_cells_name = f"#{n_cells_name}-cells" - res: List[Optional[Tuple[dtlib_Node, bytes]]] = [] + res: list[Optional[tuple[dtlib_Node, bytes]]] = [] raw = prop.value while raw: @@ -3187,7 +3187,7 @@ def _interrupt_cells(node: dtlib_Node) -> int: def _slice(node: dtlib_Node, prop_name: str, size: int, - size_hint: str) -> List[bytes]: + size_hint: str) -> list[bytes]: return _slice_helper(node, prop_name, size, size_hint, EDTError) @@ -3259,7 +3259,7 @@ class _BindingLoader(Loader): # include/devicetree.h. # -_DEFAULT_PROP_TYPES: Dict[str, str] = { +_DEFAULT_PROP_TYPES: dict[str, str] = { "compatible": "string-array", "status": "string", "ranges": "compound", # NUMS or EMPTY @@ -3272,12 +3272,12 @@ class _BindingLoader(Loader): "interrupt-controller": "boolean", } -_STATUS_ENUM: List[str] = "ok okay disabled reserved fail fail-sss".split() +_STATUS_ENUM: list[str] = "ok okay disabled reserved fail fail-sss".split() def _raw_default_property_for( name: str -) -> Dict[str, Union[str, bool, List[str]]]: - ret: Dict[str, Union[str, bool, List[str]]] = { +) -> dict[str, Union[str, bool, list[str]]]: + ret: dict[str, Union[str, bool, list[str]]] = { 'type': _DEFAULT_PROP_TYPES[name], 'required': False, } @@ -3296,7 +3296,7 @@ def _raw_default_property_for( require_compatible=False, require_description=False, ) -_DEFAULT_PROP_SPECS: Dict[str, PropertySpec] = { +_DEFAULT_PROP_SPECS: dict[str, PropertySpec] = { name: PropertySpec(name, _DEFAULT_PROP_BINDING) for name in _DEFAULT_PROP_TYPES }