31     def __init__(self, family, yaml):  argument
32         self.yaml = yaml
33         self.family = family
35         if 'name' in self.yaml:
36             self.name = self.yaml['name']
37             self.ident_name = self.name.replace('-', '_')
39         self._super_resolved = False
40         family.add_unresolved(self)
42     def __getitem__(self, key):  argument
43         return self.yaml[key]
45     def __contains__(self, key):  argument
46         return key in self.yaml
48     def get(self, key, default=None):  argument
49         return self.yaml.get(key, default)
51     def resolve_up(self, up):  argument
52         if not self._super_resolved:
54             self._super_resolved = True
56     def resolve(self):  argument
72     def __init__(self, enum_set, yaml, prev, value_start):  argument
77         self.doc = yaml.get('doc', '')
78         self.enum_set = enum_set
81             self.value = yaml['value']
83             self.value = prev.value + 1
85             self.value = value_start
87     def has_doc(self):  argument
88         return bool(self.doc)
90     def raw_value(self):  argument
91         return self.value
93     def user_value(self, as_flags=None):  argument
94         if self.enum_set['type'] == 'flags' or as_flags:
95             return 1 << self.value
97             return self.value
113     def __init__(self, family, yaml):  argument
116         self.type = yaml['type']
119         value_start = self.yaml.get('value-start', 0)
120         self.entries = dict()
121         self.entries_by_val = dict()
122         for entry in self.yaml['entries']:
123             e = self.new_entry(entry, prev_entry, value_start)
124             self.entries[e.name] = e
125             self.entries_by_val[e.raw_value()] = e
128     def new_entry(self, entry, prev_entry, value_start):  argument
129         return SpecEnumEntry(self, entry, prev_entry, value_start)
131     def has_doc(self):  argument
132         if 'doc' in self.yaml:
134         for entry in self.entries.values():
139     def get_mask(self, as_flags=None):  argument
141         for e in self.entries.values():
167     def __init__(self, family, attr_set, yaml, value):  argument
170         self.type = yaml['type']
171         self.value = value
172         self.attr_set = attr_set
173         self.is_multi = yaml.get('multi-attr', False)
174         self.struct_name = yaml.get('struct')
175         self.sub_type = yaml.get('sub-type')
176         self.byte_order = yaml.get('byte-order')
177         self.len = yaml.get('len')
178         self.display_hint = yaml.get('display-hint')
179         self.sub_message = yaml.get('sub-message')
180         self.selector = yaml.get('selector')
182         self.is_auto_scalar = self.type == "sint" or self.type == "uint"
198     def __init__(self, family, yaml):  argument
201         self.subset_of = self.yaml.get('subset-of', None)
203         self.attrs = collections.OrderedDict()
204         self.attrs_by_val = collections.OrderedDict()
206         if self.subset_of is None:
208             for elem in self.yaml['attributes']:
212                 attr = self.new_attr(elem, val)
213                 self.attrs[attr.name] = attr
214                 self.attrs_by_val[attr.value] = attr
217             real_set = family.attr_sets[self.subset_of]
218             for elem in self.yaml['attributes']:
220                 self.attrs[attr.name] = attr
221                 self.attrs_by_val[attr.value] = attr
223     def new_attr(self, elem, value):  argument
224         return SpecAttr(self.family, self, elem, value)
226     def __getitem__(self, key):  argument
227         return self.attrs[key]
229     def __contains__(self, key):  argument
230         return key in self.attrs
232     def __iter__(self):  argument
233         yield from self.attrs
235     def items(self):  argument
236         return self.attrs.items()
253     def __init__(self, family, yaml):  argument
255         self.type = yaml['type']
256         self.byte_order = yaml.get('byte-order')
257         self.enum = yaml.get('enum')
258         self.len = yaml.get('len')
259         self.display_hint = yaml.get('display-hint')
260         self.struct = yaml.get('struct')
271     def __init__(self, family, yaml):  argument
274         self.members = []
276             self.members.append(self.new_member(family, member))
278     def new_member(self, family, elem):  argument
281     def __iter__(self):  argument
282         yield from self.members
284     def items(self):  argument
285         return self.members.items()
298     def __init__(self, family, yaml):  argument
301         self.formats = collections.OrderedDict()
302         for elem in self.yaml['formats']:
303             format = self.new_format(family, elem)
304             self.formats[format.value] = format
306     def new_format(self, family, format):  argument
320     def __init__(self, family, yaml):  argument
323         self.value = yaml.get('value')
324         self.fixed_header = yaml.get('fixed-header')
325         self.attr_set = yaml.get('attribute-set')
347     def __init__(self, family, yaml, req_value, rsp_value):  argument
350         self.value = req_value if req_value == rsp_value else None
351         self.req_value = req_value
352         self.rsp_value = rsp_value
354         self.modes = yaml.keys() & {'do', 'dump', 'event', 'notify'}
355         self.is_call = 'do' in yaml or 'dump' in yaml
356         self.is_async = 'notify' in yaml or 'event' in yaml
357         self.is_resv = not self.is_async and not self.is_call
358         self.fixed_header = self.yaml.get('fixed-header', family.fixed_header)
361         self.attr_set = None
362         delattr(self, "attr_set")
364     def resolve(self):  argument
365         self.resolve_up(super())
367         if 'attribute-set' in self.yaml:
368             attr_set_name = self.yaml['attribute-set']
369         elif 'notify' in self.yaml:
370             msg = self.family.msgs[self.yaml['notify']]
372         elif self.is_resv:
375             raise Exception(f"Can't resolve attribute set for op '{self.name}'")
377             self.attr_set = self.family.attr_sets[attr_set_name]
395     def __init__(self, family, yaml):  argument
397         self.value = self.yaml.get('value')
425     def __init__(self, spec_path, schema_path=None, exclude_ops=None):  argument
431             self.license = first[len(prefix):]
436         self._resolution_list = []
438         super().__init__(self, spec)
440         self._exclude_ops = exclude_ops if exclude_ops else []
442         self.proto = self.yaml.get('protocol', 'genetlink')
443         self.msg_id_model = self.yaml['operations'].get('enum-model', 'unified')
446             schema_path = os.path.dirname(os.path.dirname(spec_path)) + f'/{self.proto}.yaml'
456             jsonschema.validate(self.yaml, schema)
458         self.attr_sets = collections.OrderedDict()
459         self.sub_msgs = collections.OrderedDict()
460         self.msgs = collections.OrderedDict()
461         self.req_by_value = collections.OrderedDict()
462         self.rsp_by_value = collections.OrderedDict()
463         self.ops = collections.OrderedDict()
464         self.ntfs = collections.OrderedDict()
465         self.consts = collections.OrderedDict()
466         self.mcast_groups = collections.OrderedDict()
467         self.kernel_family = collections.OrderedDict(self.yaml.get('kernel-family', {}))
470         while len(self._resolution_list) > 0:
472             unresolved = self._resolution_list
473             self._resolution_list = []
479                     self._resolution_list.append(elem)
488     def new_enum(self, elem):  argument
489         return SpecEnumSet(self, elem)
491     def new_attr_set(self, elem):  argument
492         return SpecAttrSet(self, elem)
494     def new_struct(self, elem):  argument
495         return SpecStruct(self, elem)
497     def new_sub_message(self, elem):  argument
498         return SpecSubMessage(self, elem);
500     def new_operation(self, elem, req_val, rsp_val):  argument
501         return SpecOperation(self, elem, req_val, rsp_val)
503     def new_mcast_group(self, elem):  argument
504         return SpecMcastGroup(self, elem)
506     def add_unresolved(self, elem):  argument
507         self._resolution_list.append(elem)
509     def _dictify_ops_unified(self):  argument
510         self.fixed_header = self.yaml['operations'].get('fixed-header')
512         for elem in self.yaml['operations']['list']:
516             op = self.new_operation(elem, val, val)
519             self.msgs[op.name] = op
521     def _dictify_ops_directional(self):  argument
522         self.fixed_header = self.yaml['operations'].get('fixed-header')
524         for elem in self.yaml['operations']['list']:
553             for exclude in self._exclude_ops:
556                 op = self.new_operation(elem, req_val, rsp_val)
561             self.msgs[op.name] = op
563     def find_operation(self, name):  argument
567       for op in self.yaml['operations']['list']:
572     def resolve(self):  argument
573         self.resolve_up(super())
575         definitions = self.yaml.get('definitions', [])
578                 self.consts[elem['name']] = self.new_enum(elem)
580                 self.consts[elem['name']] = self.new_struct(elem)
582                 self.consts[elem['name']] = elem
584         for elem in self.yaml['attribute-sets']:
585             attr_set = self.new_attr_set(elem)
586             self.attr_sets[elem['name']] = attr_set
588         for elem in self.yaml.get('sub-messages', []):
589             sub_message = self.new_sub_message(elem)
590             self.sub_msgs[sub_message.name] = sub_message
592         if self.msg_id_model == 'unified':
593             self._dictify_ops_unified()
594         elif self.msg_id_model == 'directional':
595             self._dictify_ops_directional()
597         for op in self.msgs.values():
599                 self.req_by_value[op.req_value] = op
601                 self.rsp_by_value[op.rsp_value] = op
603                 self.ops[op.name] = op
605                 self.ntfs[op.name] = op
607         mcgs = self.yaml.get('mcast-groups')
610                 mcg = self.new_mcast_group(elem)
611                 self.mcast_groups[elem['name']] = mcg