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         return self.has_entry_doc()
136     def has_entry_doc(self):  argument
137         for entry in self.entries.values():
142     def get_mask(self, as_flags=None):  argument
144         for e in self.entries.values():
170     def __init__(self, family, attr_set, yaml, value):  argument
173         self.type = yaml['type']
174         self.value = value
175         self.attr_set = attr_set
176         self.is_multi = yaml.get('multi-attr', False)
177         self.struct_name = yaml.get('struct')
178         self.sub_type = yaml.get('sub-type')
179         self.byte_order = yaml.get('byte-order')
180         self.len = yaml.get('len')
181         self.display_hint = yaml.get('display-hint')
182         self.sub_message = yaml.get('sub-message')
183         self.selector = yaml.get('selector')
185         self.is_auto_scalar = self.type == "sint" or self.type == "uint"
201     def __init__(self, family, yaml):  argument
204         self.subset_of = self.yaml.get('subset-of', None)
206         self.attrs = collections.OrderedDict()
207         self.attrs_by_val = collections.OrderedDict()
209         if self.subset_of is None:
211             for elem in self.yaml['attributes']:
215                 attr = self.new_attr(elem, val)
216                 self.attrs[attr.name] = attr
217                 self.attrs_by_val[attr.value] = attr
220             real_set = family.attr_sets[self.subset_of]
221             for elem in self.yaml['attributes']:
224                 attr = self.new_attr(combined_elem, real_attr.value)
226                 self.attrs[attr.name] = attr
227                 self.attrs_by_val[attr.value] = attr
229     def new_attr(self, elem, value):  argument
230         return SpecAttr(self.family, self, elem, value)
232     def __getitem__(self, key):  argument
233         return self.attrs[key]
235     def __contains__(self, key):  argument
236         return key in self.attrs
238     def __iter__(self):  argument
239         yield from self.attrs
241     def items(self):  argument
242         return self.attrs.items()
259     def __init__(self, family, yaml):  argument
261         self.type = yaml['type']
262         self.byte_order = yaml.get('byte-order')
263         self.enum = yaml.get('enum')
264         self.len = yaml.get('len')
265         self.display_hint = yaml.get('display-hint')
266         self.struct = yaml.get('struct')
277     def __init__(self, family, yaml):  argument
280         self.members = []
282             self.members.append(self.new_member(family, member))
284     def new_member(self, family, elem):  argument
287     def __iter__(self):  argument
288         yield from self.members
290     def items(self):  argument
291         return self.members.items()
304     def __init__(self, family, yaml):  argument
307         self.formats = collections.OrderedDict()
308         for elem in self.yaml['formats']:
309             format = self.new_format(family, elem)
310             self.formats[format.value] = format
312     def new_format(self, family, format):  argument
326     def __init__(self, family, yaml):  argument
329         self.value = yaml.get('value')
330         self.fixed_header = yaml.get('fixed-header')
331         self.attr_set = yaml.get('attribute-set')
353     def __init__(self, family, yaml, req_value, rsp_value):  argument
356         self.value = req_value if req_value == rsp_value else None
357         self.req_value = req_value
358         self.rsp_value = rsp_value
360         self.modes = yaml.keys() & {'do', 'dump', 'event', 'notify'}
361         self.is_call = 'do' in yaml or 'dump' in yaml
362         self.is_async = 'notify' in yaml or 'event' in yaml
363         self.is_resv = not self.is_async and not self.is_call
364         self.fixed_header = self.yaml.get('fixed-header', family.fixed_header)
367         self.attr_set = None
368         delattr(self, "attr_set")
370     def resolve(self):  argument
371         self.resolve_up(super())
373         if 'attribute-set' in self.yaml:
374             attr_set_name = self.yaml['attribute-set']
375         elif 'notify' in self.yaml:
376             msg = self.family.msgs[self.yaml['notify']]
378         elif self.is_resv:
381             raise Exception(f"Can't resolve attribute set for op '{self.name}'")
383             self.attr_set = self.family.attr_sets[attr_set_name]
401     def __init__(self, family, yaml):  argument
403         self.value = self.yaml.get('value')
431     def __init__(self, spec_path, schema_path=None, exclude_ops=None):  argument
437             self.license = first[len(prefix):]
442         self._resolution_list = []
444         super().__init__(self, spec)
446         self._exclude_ops = exclude_ops if exclude_ops else []
448         self.proto = self.yaml.get('protocol', 'genetlink')
449         self.msg_id_model = self.yaml['operations'].get('enum-model', 'unified')
452             schema_path = os.path.dirname(os.path.dirname(spec_path)) + f'/{self.proto}.yaml'
462             jsonschema.validate(self.yaml, schema)
464         self.attr_sets = collections.OrderedDict()
465         self.sub_msgs = collections.OrderedDict()
466         self.msgs = collections.OrderedDict()
467         self.req_by_value = collections.OrderedDict()
468         self.rsp_by_value = collections.OrderedDict()
469         self.ops = collections.OrderedDict()
470         self.ntfs = collections.OrderedDict()
471         self.consts = collections.OrderedDict()
472         self.mcast_groups = collections.OrderedDict()
473         self.kernel_family = collections.OrderedDict(self.yaml.get('kernel-family', {}))
476         while len(self._resolution_list) > 0:
478             unresolved = self._resolution_list
479             self._resolution_list = []
485                     self._resolution_list.append(elem)
494     def new_enum(self, elem):  argument
495         return SpecEnumSet(self, elem)
497     def new_attr_set(self, elem):  argument
498         return SpecAttrSet(self, elem)
500     def new_struct(self, elem):  argument
501         return SpecStruct(self, elem)
503     def new_sub_message(self, elem):  argument
504         return SpecSubMessage(self, elem);
506     def new_operation(self, elem, req_val, rsp_val):  argument
507         return SpecOperation(self, elem, req_val, rsp_val)
509     def new_mcast_group(self, elem):  argument
510         return SpecMcastGroup(self, elem)
512     def add_unresolved(self, elem):  argument
513         self._resolution_list.append(elem)
515     def _dictify_ops_unified(self):  argument
516         self.fixed_header = self.yaml['operations'].get('fixed-header')
518         for elem in self.yaml['operations']['list']:
522             op = self.new_operation(elem, val, val)
525             self.msgs[op.name] = op
527     def _dictify_ops_directional(self):  argument
528         self.fixed_header = self.yaml['operations'].get('fixed-header')
530         for elem in self.yaml['operations']['list']:
559             for exclude in self._exclude_ops:
562                 op = self.new_operation(elem, req_val, rsp_val)
567             self.msgs[op.name] = op
569     def find_operation(self, name):  argument
573       for op in self.yaml['operations']['list']:
578     def resolve(self):  argument
579         self.resolve_up(super())
581         definitions = self.yaml.get('definitions', [])
584                 self.consts[elem['name']] = self.new_enum(elem)
586                 self.consts[elem['name']] = self.new_struct(elem)
588                 self.consts[elem['name']] = elem
590         for elem in self.yaml['attribute-sets']:
591             attr_set = self.new_attr_set(elem)
592             self.attr_sets[elem['name']] = attr_set
594         for elem in self.yaml.get('sub-messages', []):
595             sub_message = self.new_sub_message(elem)
596             self.sub_msgs[sub_message.name] = sub_message
598         if self.msg_id_model == 'unified':
599             self._dictify_ops_unified()
600         elif self.msg_id_model == 'directional':
601             self._dictify_ops_directional()
603         for op in self.msgs.values():
605                 self.req_by_value[op.req_value] = op
607                 self.rsp_by_value[op.rsp_value] = op
609                 self.ops[op.name] = op
611                 self.ntfs[op.name] = op
613         mcgs = self.yaml.get('mcast-groups')
616                 mcg = self.new_mcast_group(elem)
617                 self.mcast_groups[elem['name']] = mcg