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()
252     def __init__(self, family, yaml):  argument
254         self.type = yaml['type']
255         self.byte_order = yaml.get('byte-order')
256         self.enum = yaml.get('enum')
257         self.len = yaml.get('len')
258         self.display_hint = yaml.get('display-hint')
269     def __init__(self, family, yaml):  argument
272         self.members = []
274             self.members.append(self.new_member(family, member))
276     def new_member(self, family, elem):  argument
279     def __iter__(self):  argument
280         yield from self.members
282     def items(self):  argument
283         return self.members.items()
296     def __init__(self, family, yaml):  argument
299         self.formats = collections.OrderedDict()
300         for elem in self.yaml['formats']:
301             format = self.new_format(family, elem)
302             self.formats[format.value] = format
304     def new_format(self, family, format):  argument
319     def __init__(self, family, yaml):  argument
322         self.value = yaml.get('value')
323         self.fixed_header = yaml.get('fixed-header')
324         self.attr_set = yaml.get('attribute-set')
345     def __init__(self, family, yaml, req_value, rsp_value):  argument
348         self.value = req_value if req_value == rsp_value else None
349         self.req_value = req_value
350         self.rsp_value = rsp_value
352         self.is_call = 'do' in yaml or 'dump' in yaml
353         self.is_async = 'notify' in yaml or 'event' in yaml
354         self.is_resv = not self.is_async and not self.is_call
355         self.fixed_header = self.yaml.get('fixed-header', family.fixed_header)
358         self.attr_set = None
359         delattr(self, "attr_set")
361     def resolve(self):  argument
362         self.resolve_up(super())
364         if 'attribute-set' in self.yaml:
365             attr_set_name = self.yaml['attribute-set']
366         elif 'notify' in self.yaml:
367             msg = self.family.msgs[self.yaml['notify']]
369         elif self.is_resv:
372             raise Exception(f"Can't resolve attribute set for op '{self.name}'")
374             self.attr_set = self.family.attr_sets[attr_set_name]
392     def __init__(self, family, yaml):  argument
394         self.value = self.yaml.get('value')
421     def __init__(self, spec_path, schema_path=None, exclude_ops=None):  argument
427             self.license = first[len(prefix):]
432         self._resolution_list = []
434         super().__init__(self, spec)
436         self._exclude_ops = exclude_ops if exclude_ops else []
438         self.proto = self.yaml.get('protocol', 'genetlink')
439         self.msg_id_model = self.yaml['operations'].get('enum-model', 'unified')
442             schema_path = os.path.dirname(os.path.dirname(spec_path)) + f'/{self.proto}.yaml'
452             jsonschema.validate(self.yaml, schema)
454         self.attr_sets = collections.OrderedDict()
455         self.sub_msgs = collections.OrderedDict()
456         self.msgs = collections.OrderedDict()
457         self.req_by_value = collections.OrderedDict()
458         self.rsp_by_value = collections.OrderedDict()
459         self.ops = collections.OrderedDict()
460         self.ntfs = collections.OrderedDict()
461         self.consts = collections.OrderedDict()
462         self.mcast_groups = collections.OrderedDict()
465         while len(self._resolution_list) > 0:
467             unresolved = self._resolution_list
468             self._resolution_list = []
474                     self._resolution_list.append(elem)
483     def new_enum(self, elem):  argument
484         return SpecEnumSet(self, elem)
486     def new_attr_set(self, elem):  argument
487         return SpecAttrSet(self, elem)
489     def new_struct(self, elem):  argument
490         return SpecStruct(self, elem)
492     def new_sub_message(self, elem):  argument
493         return SpecSubMessage(self, elem);
495     def new_operation(self, elem, req_val, rsp_val):  argument
496         return SpecOperation(self, elem, req_val, rsp_val)
498     def new_mcast_group(self, elem):  argument
499         return SpecMcastGroup(self, elem)
501     def add_unresolved(self, elem):  argument
502         self._resolution_list.append(elem)
504     def _dictify_ops_unified(self):  argument
505         self.fixed_header = self.yaml['operations'].get('fixed-header')
507         for elem in self.yaml['operations']['list']:
511             op = self.new_operation(elem, val, val)
514             self.msgs[op.name] = op
516     def _dictify_ops_directional(self):  argument
517         self.fixed_header = self.yaml['operations'].get('fixed-header')
519         for elem in self.yaml['operations']['list']:
548             for exclude in self._exclude_ops:
551                 op = self.new_operation(elem, req_val, rsp_val)
556             self.msgs[op.name] = op
558     def find_operation(self, name):  argument
562       for op in self.yaml['operations']['list']:
567     def resolve(self):  argument
568         self.resolve_up(super())
570         definitions = self.yaml.get('definitions', [])
573                 self.consts[elem['name']] = self.new_enum(elem)
575                 self.consts[elem['name']] = self.new_struct(elem)
577                 self.consts[elem['name']] = elem
579         for elem in self.yaml['attribute-sets']:
580             attr_set = self.new_attr_set(elem)
581             self.attr_sets[elem['name']] = attr_set
583         for elem in self.yaml.get('sub-messages', []):
584             sub_message = self.new_sub_message(elem)
585             self.sub_msgs[sub_message.name] = sub_message
587         if self.msg_id_model == 'unified':
588             self._dictify_ops_unified()
589         elif self.msg_id_model == 'directional':
590             self._dictify_ops_directional()
592         for op in self.msgs.values():
594                 self.req_by_value[op.req_value] = op
596                 self.rsp_by_value[op.rsp_value] = op
598                 self.ops[op.name] = op
600                 self.ntfs[op.name] = op
602         mcgs = self.yaml.get('mcast-groups')
605                 mcg = self.new_mcast_group(elem)
606                 self.mcast_groups[elem['name']] = mcg