Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More
How to use add_line method in pytest-bdd
Best Python code snippet using pytest-bdd_python
generate.py
Source:generate.py 
...251 def set_parameter(self, *args, **kwargs):252 self.schema.set_parameter(*args, **kwargs)253 def add_debug(self, *args, **kwargs):254 self.schema.add_debug(*args, **kwargs)255 def add_line(self, *args, **kwargs):256 self.schema.add_line(*args, **kwargs)257 def skip_line(self, *args, **kwargs):258 self.schema.skip_line(*args, **kwargs)259 def pop_line(self, *args, **kwargs):260 return self.schema.pop_line(*args, **kwargs)261 def start_block(self, *args, **kwargs):262 self.schema.start_block(*args, **kwargs)263 def end_block(self, *args, **kwargs):264 self.schema.end_block(*args, **kwargs)265 266 def c_allocate(self, *args, **kwargs):267 self.schema.c_allocate(*args, **kwargs)268 def serialize_py_varint(self, *args, **kwargs):269 self.schema.serialize_py_varint(*args, **kwargs)270 def serialize_c_varint(self, *args, **kwargs):271 self.schema.serialize_c_varint(*args, **kwargs)272 def deserialize_py_varint(self, *args, **kwargs):273 self.schema.deserialize_py_varint(*args, **kwargs)274 def deserialize_c_varint(self, *args, **kwargs):275 self.schema.deserialize_c_varint(*args, **kwargs)276 def deserialize_c_int(self, *args, **kwargs):277 self.schema.deserialize_c_int(*args, **kwargs)278@dataclass279class StructMember(SchemaElement):280 schema: Schema281 name: str282 type: Union[283 StructDefinition, 284 TableDefinition, 285 EnumDefinition, 286 Primitives.String, 287 Primitives.Boolean,288 Primitives.Int8289 ]290 default: Union[str, int, None] = None291 vector: bool = False292 vector_size: Optional[int] = None293 field_id: Optional[int] = None294 def resolve_type(self, schema):295 if self.type in BUILTIN_TYPES:296 self.type = BUILTIN_TYPES[self.type]297 else:298 self.type = schema.definitions[self.type]299 @property300 def pointer_type(self):301 if self.type.c_name.endswith('*'):302 separator = ""303 else:304 separator = " "305 if self.vector:306 return "{}{}**{}".format(self.type.c_name, separator, self.name)307 else:308 return "{}{}*{}".format(self.type.c_name, separator, self.name)309 @property310 def param_type(self):311 if self.type.c_name.endswith('*'):312 separator = ""313 else:314 separator = " "315 if self.vector:316 type_name = "{}{}*{}".format(self.type.c_name, separator, self.name)317 else:318 type_name = "{}{}{}".format(self.type.c_name, separator, self.name)319 return type_name320 @property321 def c_type(self):322 if self.type.c_name.endswith('*'):323 separator = ""324 else:325 separator = " "326 if self.vector:327 if self.vector_size:328 return "{}{}{}[{}]".format(self.type.c_name, separator, self.name, self.vector_size)329 else:330 return "{}{}*{}".format(self.type.c_name, separator, self.name)331 else:332 return "{}{}{}".format(self.type.c_name, separator, self.name)333 @property334 def cast(self):335 if self.type.c_name.endswith('*'):336 separator = ""337 else:338 separator = " "339 if self.vector:340 return "{}{}*".format(self.type.c_name, separator)341 else:342 return "{}".format(self.type.c_name)343 344 @property345 def python_type(self):346 if isinstance(self.type, (StructDefinition, TableDefinition, EnumDefinition)):347 s = self.type.name348 elif self.type is Primitives.String:349 s = 'str'350 elif self.type is Primitives.Boolean:351 s = 'bool'352 elif self.type in INTEGER_PRIMITIVES:353 s = 'int'354 if self.vector:355 s = "Optional[List[{}]]".format(s)356 else:357 s = "Optional[{}]".format(s)358 return s359 @property360 def python_parameter(self):361 return "{}: {} = None".format(self.name, self.python_type)362 def generate_typedef_field(self):363 self.add_line("{};".format(self.c_type))364 if self.vector and self.vector_size is None:365 self.add_line("size_t {}_length;".format(self.name))366 def generate_typedef_present(self):367 self.add_line("bool {}_present: 1;".format(self.name))368 def generate_signatures(self, parent: Union[StructDefinition, TableDefinition]):369 self.set_parameter("struct", parent.name)370 self.set_parameter("field", self.name)371 self.set_parameter("type_name", self.type.name)372 self.set_parameter(373 "default",374 '"{}"'.format(self.default)375 if isinstance(self.default, str) else376 self.default377 )378 params = {379 "s": """380 Any {struct}_t, returned from one of `{struct}_new()`, `{struct}_copy()`,381 or `{struct}_deserialize()`.382 """,383 }384 if self.vector:385 if self.vector_size is None:386 params[self.name] = "Array of `{field}_length` {type_name} to store in the {struct}."387 else:388 params[self.name] = "Array of " + str(self.vector_size) + " {type_name} to store in the {struct}."389 else:390 params[self.name] = "{type_name} to store in the {struct}."391 if self.vector and self.vector_size is None:392 if isinstance(self.type, StructDefinition) or self.type is Primitives.String:393 params[self.name] = "{type_name} to store in the {field} field of the given {struct}."394 self.add_c_comment(395 comment="Store a copy of the given {type_name} array in the given {struct}.",396 return_comment="True on success, false if memory allocation fails.",397 **params398 )399 self.add_line("bool {struct}_set_{field}({struct}_t *s, " + self.param_type + ", size_t {field}_length);")400 self.skip_line()401 if self.default is not None:402 self.add_c_comment(403 comment="""404 Retrieve the {field} field from the given {struct} if that field is present,405 or the default value ({default}) if the {field} field is not present.406 """,407 return_comment="Always returns true."408 )409 else:410 self.add_c_comment(411 comment="Retrieve the {field} field from the given {struct}.",412 return_comment="True if the field is present, false otherwise."413 )414 self.add_line("bool {struct}_get_{field}({struct}_t *s, " + self.pointer_type + ", size_t *{field}_length);")415 self.skip_line()416 else:417 if self.vector:418 self.add_c_comment(419 comment="Store a copy of the given {type_name} array in the {field} field of the given {struct}.",420 return_comment="True on success, false if memory allocation fails.",421 **params422 )423 elif isinstance(self.type, StructDefinition) or self.type is Primitives.String:424 self.add_c_comment(425 comment="Store a copy of the given {type_name} in the {field} field of the given {struct}.",426 return_comment="True on success, false if memory allocation fails.",427 **params428 )429 else:430 self.add_c_comment(431 comment="Store the given {type_name} in the {field} field of the given {struct}.",432 return_comment="True on success, false if memory allocation fails.",433 **params434 )435 self.add_line("bool {struct}_set_{field}({struct}_t *s, " + self.param_type + ");")436 self.skip_line()437 if self.default is not None:438 self.add_c_comment(439 comment="""440 Retrieve the {field} field from the given {struct} if that field is present,441 or the default value ({default}) if the {field} field is not present.442 """,443 return_comment="Always returns true."444 )445 else:446 self.add_c_comment(447 comment="Retrieve the {field} field from the given {struct}.",448 return_comment="True if the field is present, false otherwise."449 )450 self.add_line("bool {struct}_get_{field}({struct}_t *s, " + self.pointer_type + ");")451 self.skip_line()452 def generate_free(self, parent: Union[StructDefinition, TableDefinition]):453 self.push_parameters()454 self.set_parameter("name", self.name)455 self.set_parameter("type_name", self.type.name)456 if self.vector:457 self.start_block("if (s->{name}_present) {{")458 self.add_line("s->{name}_present = false;")459 if self.type is Primitives.String:460 if self.vector_size is None:461 self.start_block("for (size_t i=0; i < s->{name}_length; i++) {{")462 else:463 self.start_block("for (size_t i=0; i < " + str(self.vector_size) + "; i++) {{")464 self.add_line("free(s->{name}[i]);")465 self.end_block("}}")466 elif isinstance(self.type, (TableDefinition, StructDefinition)):467 if self.vector_size is None:468 self.start_block("for (size_t i=0; i < s->{name}_length; i++) {{")469 else:470 self.start_block("for (size_t i=0; i < " + str(self.vector_size) + "; i++) {{")471 self.add_line("{type_name}_free(s->{name}[i]);")472 self.end_block("}}")473 if self.vector_size is None:474 self.add_line("free(s->{name});")475 self.end_block("}}")476 elif self.type is Primitives.String:477 self.start_block("if (s->{name}_present) {{")478 self.add_line("s->{name}_present = false;")479 self.add_line("free(s->{name});")480 self.end_block("}}")481 elif isinstance(self.type, (TableDefinition, StructDefinition)):482 self.start_block("if (s->{name}_present) {{")483 self.add_line("s->{name}_present = false;")484 self.add_line("{type_name}_free(s->{name});")485 self.end_block("}}")486 self.pop_parameters()487 def generate_c_deserialize(self, parent: Union[StructDefinition, TableDefinition]):488 self.push_parameters()489 self.set_parameter("name", self.name)490 self.set_parameter("type_name", self.type.name)491 self.set_parameter("field_id", self.field_id)492 self.start_block("if (bitfield[{}] & {}) {{{{".format(493 self.field_id // 8,494 1 << (7 - self.field_id & 7)495 ))496 if self.vector:497 self.set_parameter("length", self.vector_size if self.vector_size is not None else "vector_size")498 # Pre for loop499 if self.vector_size is None:500 self.deserialize_c_varint("vector_size", declare=True)501 self.add_line("s->{name} = malloc(vector_size * sizeof(*s->{name}));")502 self.start_block("for (size_t i = 0; i < {length}; i++) {{")503 # Body of the for loop504 if isinstance(self.type, (TableDefinition, StructDefinition)):505 self.deserialize_c_varint("{name}_size", declare=True)506 self.start_block("if (bytes_read + {name}_size > buffer_size) {{")507 self.start_block("for (size_t j = 0; j < i; j++) {{")508 self.add_line("{type_name}_free(s->{name}[j]);")509 self.end_block("}}")510 self.add_debug('printf("Not enough bytes remaining to deserialize nested table: (%zu/%zu)\\n", buffer_size-bytes_read, {name}_size);')511 self.add_line("goto ERROR;")512 self.end_block("}}")513 self.add_line("{type_name}_t *{name} = {type_name}_deserialize(buffer + bytes_read, {name}_size);")514 self.start_block("if ({name} == NULL) {{")515 self.start_block("for (size_t j = 0; j < i; j++) {{")516 self.add_line("{type_name}_free(s->{name}[j]);")517 self.end_block("}}")518 self.add_debug('printf("Nested deserialize failed\\n");')519 self.add_line("goto ERROR;")520 self.end_block("}}")521 self.add_line("bytes_read += {name}_size;")522 self.add_line("s->{name}[i] = {name};")523 elif isinstance(self.type, EnumDefinition):524 self.deserialize_c_int("{name}", self.type.size.byte_width, declare=True)525 self.add_line("s->{name}[i] = ({type_name}_e){name};")526 elif self.type in INTEGER_PRIMITIVES:527 self.deserialize_c_int("{name}", self.type.byte_width, declare=True, signed=self.type.signed)528 self.add_line("s->{name}[i] = {name};")529 elif self.type is Primitives.String: 530 self.deserialize_c_varint("{name}_length", declare=True)531 self.start_block("if (bytes_read + {name}_length > buffer_size) {{")532 self.add_debug('printf("Not enough bytes remaining to deserialize string: (%zu/%zu)\\n", buffer_size-bytes_read, {name}_length);')533 self.add_line("goto ERROR;")534 self.end_block("}}")535 self.add_line("char *{name} = malloc({name}_length + 1);")536 self.start_block("if ({name} == NULL) {{")537 self.add_debug('printf("Malloc failure\\n");')538 self.add_line("goto ERROR;")539 self.end_block("}}")540 self.add_line("memcpy({name}, buffer + bytes_read, {name}_length);")541 self.add_line("{name}[{name}_length] = '\\0';")542 self.add_line("bytes_read += {name}_length;")543 self.add_line("s->{name}[i] = {name};")544 elif self.type is Primitives.Boolean:545 self.start_block("if (bytes_read + 1 > buffer_size) {{")546 self.add_debug('printf("Not enough bytes remaining to deserialize bool\\n");')547 self.add_line("goto ERROR;")548 self.end_block("}}")549 self.add_line("s->{name}[i] = (bool)(buffer[bytes_read + i / 8] & (1 << (7 - (i & 7))));")550 self.end_block("}}")551 # Post for loop552 if self.vector_size is None:553 self.add_line("s->{name}_length = vector_size;")554 self.add_line("s->{name}_present = true;")555 if self.type is Primitives.Boolean:556 self.add_line("bytes_read += (({length} - 1) / 8) + 1;")557 else:558 if isinstance(self.type, (TableDefinition, StructDefinition)):559 self.deserialize_c_varint("{name}_size", declare=True)560 self.start_block("if (bytes_read + {name}_size > buffer_size) {{")561 self.add_debug('printf("Not enough bytes remaining to deserialize nested table: (%zu/%zu)\\n", buffer_size-bytes_read, {name}_size);')562 self.add_line("goto ERROR;")563 self.end_block("}}")564 self.add_line("{type_name}_t *{name} = {type_name}_deserialize(buffer + bytes_read, {name}_size);")565 self.start_block("if ({name} == NULL) {{")566 self.add_debug('printf("Nested deserialize failed\\n");')567 self.add_line("goto ERROR;")568 self.end_block("}}")569 self.add_line("bytes_read += {name}_size;")570 self.add_line("s->{name} = {name};")571 self.add_line("s->{name}_present = true;")572 elif isinstance(self.type, EnumDefinition):573 self.deserialize_c_int("{name}", self.type.size.byte_width, declare=True)574 self.add_line("s->{name} = ({type_name}_e){name};")575 self.add_line("s->{name}_present = true;")576 elif self.type in INTEGER_PRIMITIVES:577 self.deserialize_c_int("{name}", self.type.byte_width, declare=True, signed=self.type.signed)578 self.add_line("s->{name} = {name};")579 self.add_line("s->{name}_present = true;")580 elif self.type is Primitives.String: 581 self.deserialize_c_varint("{name}_length", declare=True)582 self.start_block("if (bytes_read + {name}_length > buffer_size) {{")583 self.add_debug('printf("Not enough bytes remaining to deserialize string: (%zu/%zu)\\n", buffer_size-bytes_read, {name}_length);')584 self.add_line("goto ERROR;")585 self.end_block("}}")586 self.add_line("char *{name} = malloc({name}_length + 1);")587 self.start_block("if ({name} == NULL) {{")588 self.add_debug('printf("Malloc failed\\n");')589 self.add_line("goto ERROR;")590 self.end_block("}}")591 self.add_line("memcpy({name}, buffer + bytes_read, {name}_length);")592 self.add_line("{name}[{name}_length] = '\\0';")593 self.add_line("bytes_read += {name}_length;")594 self.add_line("s->{name} = {name};")595 self.add_line("s->{name}_present = true;")596 elif self.type is Primitives.Boolean:597 self.start_block("if (bytes_read + 1 > buffer_size) {{")598 self.add_debug('printf("Not enough bytes remaining to deserialize bool\\n");')599 self.add_line("goto ERROR;")600 self.end_block("}}")601 self.add_line("s->{name} = (bool)buffer[bytes_read];")602 self.add_line("bytes_read += 1;")603 self.add_line("s->{name}_present = true;")604 self.end_block("}}")605 self.pop_parameters()606 def generate_c_serialize(self, parent: Union[StructDefinition, TableDefinition]):607 self.push_parameters()608 self.set_parameter("name", self.name)609 self.set_parameter("type_name", self.type.name)610 self.set_parameter("field_id", self.field_id)611 self.start_block("if (s->{name}_present) {{")612 self.add_line("buffer[bitfield_index+{}] |= {};".format(613 self.field_id // 8,614 1 << (7 - self.field_id & 7)615 ))616 617 if self.vector:618 self.set_parameter("length", self.vector_size if self.vector_size is not None else "s->{}_length".format(self.name))619 if self.vector_size is None:620 self.serialize_c_varint("{length}")621 # Pre for-loop622 if isinstance(self.type, (TableDefinition, StructDefinition)):623 pass624 elif self.type is Primitives.String:625 pass626 elif isinstance(self.type, EnumDefinition):627 self.set_parameter("byte_width", self.type.size.byte_width)628 self.set_parameter("c_type", self.type.size.c_name)629 if self.type.size.byte_width in (2,4,8):630 converter = "htobe{}".format(self.type.size.byte_width * 8)631 else:632 converter = ""633 self.set_parameter("converter", converter)634 self.c_allocate("{byte_width} * {length}")635 elif self.type in INTEGER_PRIMITIVES:636 self.set_parameter("byte_width", self.type.byte_width)637 self.set_parameter("c_type", self.type.c_name)638 if self.type.byte_width in (2,4,8):639 converter = "htobe{}".format(self.type.byte_width * 8)640 else:641 converter = ""642 self.set_parameter("converter", converter)643 self.c_allocate("{byte_width} * {length}")644 elif self.type is Primitives.Boolean:645 self.add_line("size_t byte_count = (({length} - 1) / 8) + 1;")646 self.c_allocate("byte_count")647 self.add_line("bzero(buffer + bytes_written, byte_count);")648 self.start_block("for (size_t i = 0; i < {length}; i++) {{")649 # Mid for-loop650 if isinstance(self.type, (TableDefinition, StructDefinition)):651 self.add_line("uint8_t *child_buffer;")652 self.add_line("size_t child_buffer_size;")653 self.add_line("{type_name}_serialize(s->{name}[i], &child_buffer, &child_buffer_size);")654 self.serialize_c_varint("child_buffer_size")655 self.c_allocate("child_buffer_size")656 self.add_line("memcpy(buffer + bytes_written, child_buffer, child_buffer_size);")657 self.add_line("bytes_written += child_buffer_size;")658 self.add_line("free(child_buffer);")659 elif isinstance(self.type, EnumDefinition):660 self.add_line("*({c_type}*)(buffer + bytes_written) = {converter}(({c_type})s->{name}[i]);")661 self.add_line("bytes_written += {byte_width};")662 elif self.type in INTEGER_PRIMITIVES:663 self.add_line("(({c_type}*)(buffer + bytes_written))[0] = {converter}(({c_type})s->{name}[i]);")664 self.add_line("bytes_written += {byte_width};")665 elif self.type is Primitives.String:666 self.add_line("size_t string_size = strlen(s->{name}[i]);")667 self.serialize_c_varint("string_size")668 self.c_allocate("string_size")669 self.add_line("memcpy(buffer + bytes_written, s->{name}[i], string_size);")670 self.add_line("bytes_written += string_size;")671 elif self.type is Primitives.Boolean:672 self.start_block("if (s->{name}[i]) {{")673 self.add_line("(buffer + bytes_written + i / 8)[0] |= 1 << (7 - (i & 7));")674 self.end_block("}}")675 else:676 raise TypeError("Unrecognized member type '{}'".format(self.type))677 self.end_block("}}")678 # Post for-loop679 if self.type is Primitives.Boolean:680 self.add_line("bytes_written += byte_count;")681 else:682 if isinstance(self.type, (TableDefinition, StructDefinition)):683 self.add_line("uint8_t *child_buffer;")684 self.add_line("size_t child_buffer_size;")685 self.add_line("{type_name}_serialize(s->{name}, &child_buffer, &child_buffer_size);")686 self.serialize_c_varint("child_buffer_size")687 self.c_allocate("child_buffer_size")688 self.add_line("memcpy(buffer + bytes_written, child_buffer, child_buffer_size);")689 self.add_line("bytes_written += child_buffer_size;")690 self.add_line("free(child_buffer);")691 elif isinstance(self.type, EnumDefinition):692 if self.type.size.byte_width in (2,4,8):693 converter = "htobe{}".format(self.type.size.byte_width * 8)694 else:695 converter = ""696 self.set_parameter("converter", converter)697 self.set_parameter("byte_width", self.type.size.byte_width)698 self.set_parameter("c_type", self.type.size.c_name)699 self.c_allocate("{byte_width}")700 self.add_line("(({c_type}*)(buffer + bytes_written))[0] = {converter}(s->{name});")701 self.add_line("bytes_written += {byte_width};")702 elif self.type in INTEGER_PRIMITIVES:703 if self.type.byte_width in (2,4,8):704 converter = "htobe{}".format(self.type.byte_width * 8)705 else:706 converter = ""707 self.set_parameter("converter", converter)708 self.set_parameter("byte_width", self.type.byte_width)709 self.set_parameter("c_type", self.type.c_name)710 self.c_allocate("{byte_width}")711 self.add_line("(({c_type}*)(buffer + bytes_written))[0] = {converter}(s->{name});")712 self.add_line("bytes_written += {byte_width};")713 elif self.type is Primitives.String:714 self.add_line("size_t string_size = strlen(s->{name});")715 self.serialize_c_varint("string_size")716 self.c_allocate("string_size")717 self.add_line("memcpy(buffer + bytes_written, s->{name}, string_size);")718 self.add_line("bytes_written += string_size;")719 elif self.type is Primitives.Boolean:720 self.c_allocate(1)721 self.start_block("if (s->{name}) {{")722 self.add_line("((uint8_t*)(buffer + bytes_written))[0] = 1;")723 self.end_block("}}")724 self.start_block("else {{")725 self.add_line("((uint8_t*)(buffer + bytes_written))[0] = 0;")726 self.end_block("}}")727 self.add_line("bytes_written += 1;")728 else:729 raise TypeError("Unrecognized member type '{}'".format(self.type))730 self.end_block("}}")731 self.pop_parameters()732 def generate_copy_sets(self, parent: Union[StructDefinition, TableDefinition]):733 self.push_parameters()734 self.set_parameter("parent_name", parent.name)735 self.set_parameter("name", self.name)736 self.set_parameter("cast", self.cast)737 self.start_block("if (s->{name}_present) {{")738 if self.vector and not self.vector_size:739 self.start_block("if (!{parent_name}_set_{name}(new_s, ({cast})s->{name}, s->{name}_length)) {{")740 else:741 self.start_block("if (!{parent_name}_set_{name}(new_s, s->{name})) {{")742 self.add_line("{parent_name}_free(new_s);")743 self.add_line("return NULL;")744 self.end_block("}}")745 self.end_block("}}")746 self.pop_parameters()747 def generate_get_set(self, parent: Union[StructDefinition, TableDefinition]):748 self.push_parameters()749 self.set_parameter("parent_name", parent.name)750 self.set_parameter("name", self.name)751 self.set_parameter("param_type", self.param_type)752 self.set_parameter("pointer_type", self.pointer_type)753 self.set_parameter("type_name", self.type.name)754 self.set_parameter("vector_size", self.vector_size)755 self.set_parameter("default", self.default)756 if self.vector_size is None:757 self.set_parameter("length", "{}_length".format(self.name))758 else:759 self.set_parameter("length", str(self.vector_size))760 # Set761 if self.vector and self.vector_size is None:762 self.start_block("bool {parent_name}_set_{name}({parent_name}_t *s, {param_type}, size_t {name}_length) {{")763 else:764 self.start_block("bool {parent_name}_set_{name}({parent_name}_t *s, {param_type}) {{")765 if self.vector:766 self.generate_free(parent)767 # Allocate space for sizeless arrays768 if self.vector_size is None:769 self.add_line("s->{name}_length = {name}_length;")770 self.add_line("s->{name} = malloc(sizeof(*{name}) * {name}_length);")771 self.start_block("if (s->{name} == NULL) {{")772 self.add_line("return false;")773 self.end_block("}}")774 # Strdup() in all strings775 if self.type is Primitives.String:776 self.start_block("for (size_t i=0; i < {length}; i++) {{")777 self.add_line("s->{name}[i] = strdup({name}[i]);")778 self.start_block("if (s->{name}[i] == NULL) {{")779 self.start_block("for (size_t j=0; j < i; j++) {{")780 self.add_line("free(s->{name}[j]);")781 self.end_block("}}")782 self.add_line("return false;")783 self.end_block("}}")784 self.end_block("}}")785 # <name>_copy() in all structs786 elif isinstance(self.type, (TableDefinition, StructDefinition)):787 self.start_block("for (size_t i=0; i < {length}; i++) {{")788 self.add_line("s->{name}[i] = {type_name}_copy({name}[i]);")789 self.start_block("if (s->{name}[i] == NULL) {{")790 self.start_block("for (size_t j=0; j < i; j++) {{")791 self.add_line("{type_name}_free(s->{name}[j]);")792 self.end_block("}}")793 self.add_line("return false;")794 self.end_block("}}")795 self.end_block("}}")796 else:797 self.add_line("memcpy(s->{name}, {name}, sizeof(*{name}) * {length});")798 elif self.type is Primitives.String:799 self.generate_free(parent)800 self.add_line("s->{name} = strdup({name});")801 self.start_block("if (s->{name} == NULL) {{")802 self.add_line("return false;")803 self.end_block("}}")804 elif isinstance(self.type, (TableDefinition, StructDefinition)):805 self.generate_free(parent)806 self.add_line("s->{name} = {type_name}_copy({name});")807 self.start_block("if (s->{name} == NULL) {{")808 self.add_line("return false;")809 self.end_block("}}")810 else:811 self.add_line("s->{name} = {name};")812 self.add_line("s->{name}_present = true;")813 self.add_line("return true;")814 self.end_block("}}")815 self.skip_line()816 # Get817 if self.vector and self.vector_size is None:818 self.start_block("bool {parent_name}_get_{name}({parent_name}_t *s, {pointer_type}, size_t *{name}_length) {{")819 else:820 self.start_block("bool {parent_name}_get_{name}({parent_name}_t *s, {pointer_type}) {{")821 self.start_block("if (s->{name}_present) {{")822 if self.vector and self.vector_size is not None:823 self.add_line("*{name} = (void *)&s->{name};")824 else:825 self.add_line("*{name} = s->{name};")826 if self.vector and self.vector_size is None:827 self.add_line("*{name}_length = s->{name}_length;")828 self.end_block("}}")829 self.start_block("else {{")830 if isinstance(self.default, str):831 self.add_line('*{name} = (char *)"{default}";')832 elif isinstance(self.default, int):833 self.add_line("*{name} = {default};")834 else:835 self.add_line("return false;")836 self.end_block("}}")837 self.add_line("return true;")838 self.end_block("}}")839 self.skip_line()840 self.pop_parameters()841 def generate_print(self, parent: Union[StructDefinition, TableDefinition]):842 self.push_parameters()843 self.set_parameter("name", self.name)844 self.set_parameter("type_name", self.type.name)845 self.start_block("if (s->{name}_present) {{")846 if self.vector:847 self.set_parameter("length", self.vector_size if self.vector_size is not None else "s->{}_length".format(self.name))848 self.add_line('printf_indent(indent, "{name} [\\n");')849 self.add_line("indent += 1;")850 self.start_block("for (size_t i = 0; i < {length}; i++) {{")851 if isinstance(self.type, (TableDefinition, StructDefinition)):852 self.add_line("{type_name}_print_indent(s->{name}[i], indent);")853 elif isinstance(self.type, EnumDefinition):854 self.add_line('printf_indent(indent, "%u\\n", s->{name}[i]);')855 elif self.type in INTEGER_PRIMITIVES:856 self.add_line('printf_indent(indent, "%x\\n", s->{name}[i]);')857 elif self.type is Primitives.String: 858 self.add_line('printf_indent(indent, "\\"%s\\"\\n", s->{name}[i]);')859 elif self.type is Primitives.Boolean:860 self.add_line('printf_indent(indent, "%s\\n", (s->{name}[i] ? "True" : "False"));')861 self.end_block("}}")862 self.add_line("indent -= 1;")863 self.add_line('printf_indent(indent, "]\\n");')864 else:865 if isinstance(self.type, (TableDefinition, StructDefinition)):866 self.add_line("{type_name}_print_indent(s->{name}, indent);")867 elif isinstance(self.type, EnumDefinition):868 self.add_line('printf_indent(indent, "{name} = %u\\n", s->{name});')869 elif self.type in INTEGER_PRIMITIVES:870 self.add_line('printf_indent(indent, "{name} = %x\\n", s->{name});')871 elif self.type is Primitives.String: 872 self.add_line('printf_indent(indent, "{name} = \\"%s\\"\\n", s->{name});')873 elif self.type is Primitives.Boolean:874 self.add_line('printf_indent(indent, "{name} = %s\\n", (s->{name} ? "True" : "False"));')875 self.end_block("}}")876 self.start_block("else {{")877 self.add_line('printf_indent(indent, "{name} not present.\\n");')878 self.end_block("}}")879 self.pop_parameters()880 def generate_python_serialize(self):881 """882 Struct Member - Serialize883 """884 if self.vector:885 if self.vector_size is None:886 self.add_line("field_length = len(self.{field})")887 self.serialize_py_varint("field_length")888 else:889 self.set_parameter("vector_size", self.vector_size)890 self.add_line("field_length = {vector_size}")891 if self.type is Primitives.Boolean:892 self.add_line("data = bytearray(((field_length - 1) // 8) + 1)")893 self.start_block("for i in range(field_length):")894 if isinstance(self.type, (StructDefinition, TableDefinition)):895 self.add_line("child_buf = self.{field}[i].serialize()")896 self.add_line("child_length = len(child_buf)")897 self.serialize_py_varint("child_length")898 self.add_line("buf.extend(child_buf)")899 elif isinstance(self.type, EnumDefinition):900 self.set_parameter("bit_width", self.type.size.byte_width*8)901 self.add_line("buf.extend(uint{bit_width}(self.{field}[i]))")902 elif self.type is Primitives.String:903 self.add_line("string_length = len(self.{field}[i])")904 self.serialize_py_varint("string_length")905 self.add_line("buf.extend(self.{field}[i].encode('utf-8'))")906 elif self.type is Primitives.Boolean:907 self.start_block("if self.{field}[i]:")908 self.add_line("data[i//8] |= 1 << (7 - (i & 7))")909 self.end_block()910 elif self.type in INTEGER_PRIMITIVES:911 self.set_parameter("bit_width", self.type.byte_width*8)912 self.add_line("buf.extend(uint{bit_width}(self.{field}[i]))")913 else:914 raise TypeError("Unrecognized struct member type")915 self.end_block()916 if self.type is Primitives.Boolean:917 self.add_line("buf.extend(data)")918 else:919 if isinstance(self.type, (StructDefinition, TableDefinition)):920 self.add_line("child_buf = self.{field}.serialize()")921 self.add_line("child_length = len(child_buf)")922 self.serialize_py_varint("child_length")923 self.add_line("buf.extend(child_buf)")924 elif isinstance(self.type, EnumDefinition):925 self.set_parameter("bit_width", self.type.size.byte_width*8)926 self.add_line("buf.extend(uint{bit_width}(self.{field}))")927 elif self.type is Primitives.String:928 self.add_line("string_length = len(self.{field})")929 self.serialize_py_varint("string_length")930 self.add_line("buf.extend(self.{field}.encode('utf-8'))")931 elif self.type is Primitives.Boolean:932 self.start_block("if self.{field}:")933 self.add_line("buf.extend(uint8(1))")934 self.end_block()935 self.start_block("else:")936 self.add_line("buf.extend(uint8(0))")937 self.end_block()938 elif self.type in INTEGER_PRIMITIVES:939 self.set_parameter("bit_width", self.type.byte_width*8)940 self.add_line("buf.extend(uint{bit_width}(self.{field}))")941 else:942 raise TypeError("Unrecognized struct member type")943 def generate_python_deserialize(self):944 """945 Struct Member - Deserialize946 """947 self.start_block("if buf[bitfield_index + {}] & {}:".format(948 self.field_id // 8,949 1 << (7 - self.field_id & 7)950 ))951 if self.vector:952 # Before for loop953 if self.vector_size is None:954 self.deserialize_py_varint("field_length")955 else:956 self.set_parameter("vector_size", self.vector_size)957 self.add_line("field_length = {vector_size}")958 959 self.add_line("values = []")960 if self.type is Primitives.Boolean:961 self.add_line("data_size = ((field_length - 1) // 8) + 1")962 self.add_line("data = buf[buf_index:buf_index + data_size]")963 self.add_line("buf_index += data_size")964 965 # During for loop966 self.start_block("for i in range(field_length):")967 if isinstance(self.type, (StructDefinition, TableDefinition)):968 self.deserialize_py_varint("child_length")969 self.add_line("child_buf = buf[buf_index:buf_index+child_length]")970 self.add_line("buf_index += child_length")971 self.add_line("values.append({type_name}.deserialize(child_buf))")972 elif isinstance(self.type, EnumDefinition):973 self.set_parameter("byte_width", self.type.size.byte_width)974 self.add_line("values.append({type_name}(unsigned_int(buf[buf_index:buf_index+{byte_width}])))")975 self.add_line("buf_index += {byte_width}")976 elif self.type is Primitives.String:977 self.deserialize_py_varint("string_length")978 self.add_line("values.append(buf[buf_index:buf_index+string_length].decode('utf-8'))")979 self.add_line("buf_index += string_length")980 elif self.type is Primitives.Boolean:981 self.start_block("if data[i//8] & (1 << (7 - (i & 7))):")982 self.add_line("values.append(True)")983 self.end_block()984 self.start_block("else:")985 self.add_line("values.append(False)")986 self.end_block()987 elif self.type in INTEGER_PRIMITIVES:988 self.set_parameter("byte_width", self.type.byte_width)989 self.set_parameter("int_type", "signed_int" if self.type.signed else "unsigned_int")990 self.add_line("values.append({int_type}(buf[buf_index:buf_index+{byte_width}]))")991 self.add_line("buf_index += {byte_width}")992 else:993 raise TypeError("Unrecognized struct member type")994 self.end_block()995 # After for loop996 self.add_line("table.{field} = values")997 else:998 if isinstance(self.type, (StructDefinition, TableDefinition)):999 self.deserialize_py_varint("child_length")1000 self.add_line("child_buf = buf[buf_index:buf_index+child_length]")1001 self.add_line("buf_index += child_length")1002 self.add_line("table.{field} = {type_name}.deserialize(child_buf)")1003 elif isinstance(self.type, EnumDefinition):1004 self.set_parameter("byte_width", self.type.size.byte_width)1005 self.add_line("table.{field} = {type_name}(unsigned_int(buf[buf_index:buf_index+{byte_width}]))")1006 self.add_line("buf_index += {byte_width}")1007 elif self.type is Primitives.String:1008 self.deserialize_py_varint("string_length")1009 self.add_line("table.{field} = buf[buf_index:buf_index+string_length].decode('utf-8')")1010 self.add_line("buf_index += string_length")1011 elif self.type is Primitives.Boolean:1012 self.add_line("table.{field} = (buf[buf_index] != 0)")1013 self.add_line("buf_index += 1")1014 elif self.type in INTEGER_PRIMITIVES:1015 self.set_parameter("byte_width", self.type.byte_width)1016 self.set_parameter("int_type", "signed_int" if self.type.signed else "unsigned_int")1017 self.add_line("table.{field} = {int_type}(buf[buf_index:buf_index+{byte_width}])")1018 self.add_line("buf_index += {byte_width}")1019 else:1020 raise TypeError("Unrecognized struct member type")1021 self.end_block()1022 def generate_python_initialize(self):1023 """1024 Struct Member - Initialization1025 """1026 self.set_parameter("type_name", self.type.name)1027 if self.vector and self.vector_size is None:1028 self.start_block("if {field} is None:")1029 self.add_line("self.{field} = []")1030 self.end_block()1031 self.start_block("else:")1032 self.add_line("self.{field} = {field}")1033 self.end_block()1034 else:1035 self.add_line("self.{field} = {field}")1036@dataclass1037class EnumMember(SchemaElement):1038 schema: Schema1039 name: str1040 value: Optional[int] = None1041 def resolve_value(self, parent):1042 if self.value is None:1043 self.value = parent.next_value1044 parent.values.add(self.value)1045 parent.next_value = self.value + 11046@dataclass1047class StructDefinition(SchemaElement):1048 schema: Schema1049 name: str1050 members: List[StructMember] = field(default_factory=list)1051 table_id: Optional[int] = None1052 @property1053 def c_name(self):1054 return "{}_t *".format(self.name)1055 def resolve_types(self, schema):1056 for struct_member in self.members:1057 struct_member.resolve_type(schema)1058 def validate(self):1059 for struct_member in self.members:1060 # Below this are checks run only when a default is present1061 if struct_member.default is None:1062 continue1063 # If this type is a struct or table, verify no default is set1064 elif isinstance(struct_member.type, (StructDefinition, TableDefinition)):1065 raise TypeError("Struct member of type '{} (Struct)' {}.{} cannot have a default value.".format(1066 struct_member.type.name, self.name, struct_member.name))1067 # If this type is an enum, verify default is in the range of enum values1068 elif isinstance(struct_member.type, EnumDefinition):1069 if struct_member.default not in struct_member.type.values:1070 raise TypeError("Struct member of type '{} (Enum)' {}.{} cannot have value '{}'".format(1071 struct_member.type.name, self.name, struct_member.name, struct_member.default))1072 # If this type is an integer primitive, verify default is an int1073 elif struct_member.type in INTEGER_PRIMITIVES:1074 if not isinstance(struct_member.default, int):1075 raise TypeError("The default value of {}.{} must be an integer.".format(1076 self.name, struct_member.name))1077 # If this type is a string primitive, verify default is a string1078 elif struct_member.type is Primitives.String:1079 if not isinstance(struct_member.default, str):1080 raise TypeError("The default value of string {}.{} must be a string.".format(1081 self.name, struct_member.name))1082 # If this type is a boolean primitive, verify default is 0 or 11083 elif struct_member.type is Primitives.Boolean:1084 if struct_member.default != 0 and struct_member.default != 1:1085 raise TypeError("The default value of boolean {}.{} must be true (1) or false (0).".format(1086 self.name, struct_member.name))1087 # Unrecognized type1088 else:1089 raise TypeError("Struct member {}.{} has an unrecognized type: '{}'".format(1090 self.name, struct_member.name, struct_member.type))1091 def generate_typedefs(self):1092 self.set_parameter("name", self.name)1093 self.start_block("typedef struct {name}_t {{")1094 for member in self.members:1095 member.generate_typedef_field()1096 for member in self.members:1097 member.generate_typedef_present()1098 self.end_block("}} {name}_t;")1099 def generate_signatures(self):1100 self.set_parameter("name", self.name)1101 self.add_c_comment(1102 comment="Creates a new {name}_t on the heap.",1103 return_comment="A newly allocated {name}_t. Must be freed with `{name}_free()`."1104 )1105 self.add_line("{name}_t *{name}_new(void);")1106 self.skip_line()1107 self.add_c_comment(1108 comment="Creates a copy of an existing {name}_t.",1109 return_comment="A newly allocated {name}_t. Must be freed with `{name}_free()`."1110 )1111 self.add_line("{name}_t *{name}_copy({name}_t *s);")1112 self.skip_line()1113 self.add_c_comment(1114 comment="""1115 Deallocates an existing {name}_t that was previously allocated with `{name}_new()`,1116 `{name}_copy()`, or `{name}_deserialize()`.1117 """1118 )1119 self.add_line("void {name}_free({name}_t *s);")1120 self.skip_line()1121 self.add_c_comment(1122 comment="Serialize a {name}_t into a buffer. The {name}_t is unchanged.",1123 s="The {name}_t to serialize.",1124 buffer="Place to store the newly allocated buffer.",1125 buffer_size="Place to store the size of the newly allocated buffer.",1126 return_comment="True on success, false if memory allocation fails.",1127 )1128 self.add_line("bool {name}_serialize({name}_t *s, uint8_t **buffer, size_t *buffer_size);")1129 self.skip_line()1130 self.add_c_comment(1131 comment="Parse a buffer that was created by serializing a {name}_t and re-create the {name}_t.",1132 return_comment="A newly allocated {name}_t. Must be freed with `{name}_free()`."1133 )1134 self.add_line("{name}_t *{name}_deserialize(const uint8_t *buffer, size_t buffer_size);")1135 self.skip_line()1136 self.add_c_comment(1137 return_comment="True if the given buffer holds a valid serialized {name}_t, false otherwise.",1138 )1139 self.add_line("bool {name}_verify(const uint8_t *buffer, size_t buffer_size);")1140 self.skip_line()1141 self.add_line("void {name}_print({name}_t *s);")1142 self.skip_line()1143 for member in self.members:1144 member.generate_signatures(self)1145 def generate_c_source(self):1146 self.set_parameter("name", self.name)1147 self.set_parameter("table_id", self.table_id)1148 self.set_parameter("bitfield_byte_width", (len(self.members) - 1) // 8 + 1)1149 # Copy1150 self.start_block("{name}_t *{name}_copy({name}_t *s) {{")1151 self.add_line("{name}_t *new_s = {name}_new();")1152 self.start_block("if (new_s == NULL) {{")1153 self.add_line("return NULL;")1154 self.end_block("}}")1155 for member in self.members:1156 member.generate_copy_sets(self)1157 self.add_line("return new_s;")1158 self.end_block("}}")1159 self.skip_line()1160 # New1161 self.start_block("{name}_t *{name}_new(void) {{")1162 self.add_line("return calloc(1, sizeof({name}_t));")1163 self.end_block("}}")1164 self.skip_line()1165 # Free1166 self.start_block("void {name}_free({name}_t *s) {{")1167 for member in self.members:1168 member.generate_free(self)1169 self.add_line("free(s);")1170 self.end_block("}}")1171 self.skip_line()1172 1173 # Serialize1174 self.start_block("bool {name}_serialize({name}_t *s, uint8_t **out_buffer, size_t *out_buffer_size) {{")1175 self.add_line("size_t buffer_size = 32;")1176 self.add_line("uint8_t *buffer = malloc(buffer_size);")1177 self.add_line("size_t bytes_written = 0;")1178 if self.table_id > 0xFFFFFFFF:1179 self.c_allocate(9)1180 self.add_line("buffer[bytes_written] = 0xFF;")1181 self.add_line("bytes_written += 1;")1182 self.add_line("((uint64_t*)(buffer + bytes_written))[0] = TABLE_TYPE_{name};")1183 self.add_line("bytes_written += 8;")1184 elif self.table_id > 0xFFFF:1185 self.c_allocate(5)1186 self.add_line("buffer[bytes_written] = 0xFE;")1187 self.add_line("bytes_written += 1;")1188 self.add_line("((uint32_t*)(buffer + bytes_written))[0] = TABLE_TYPE_{name};")1189 self.add_line("bytes_written += 4;")1190 elif self.table_id >= 0xFD:1191 self.c_allocate(3)1192 self.add_line("buffer[bytes_written] = 0xFD;")1193 self.add_line("bytes_written += 1;")1194 self.add_line("((uint16_t*)(buffer + bytes_written))[0] = TABLE_TYPE_{name};")1195 self.add_line("bytes_written += 2;")1196 else:1197 self.c_allocate(1)1198 self.add_line("((uint8_t*)(buffer + bytes_written))[0] = TABLE_TYPE_{name};")1199 self.add_line("bytes_written += 1;")1200 if len(self.members) > 0:1201 self.add_line("size_t bitfield_index = bytes_written;")1202 # Allocate room for the bitfield1203 self.c_allocate((len(self.members) - 1) // 8 + 1)1204 self.add_line("bzero(buffer + bytes_written, {bitfield_byte_width});")1205 self.add_line("bytes_written += {bitfield_byte_width};")1206 for member in self.members:1207 member.generate_c_serialize(self)1208 self.add_line("*out_buffer = buffer;")1209 self.add_line("*out_buffer_size = bytes_written;")1210 self.add_line("return true;")1211 self.end_block("}}")1212 self.skip_line()1213 # Deserialize1214 self.start_block("{name}_t *{name}_deserialize(const uint8_t *buffer, size_t buffer_size) {{")1215 self.add_line("{name}_t* s = {name}_new();")1216 self.start_block("if (s == NULL) {{")1217 self.add_line("return NULL;")1218 self.end_block("}}")1219 self.add_line("size_t bytes_read = 0;")1220 self.deserialize_c_varint("table_id", declare=True)1221 self.start_block("if (table_id != {table_id}) {{")1222 self.add_debug('printf("Table ID in buffer doesn\'t match: %zu instead of %i\\n", table_id, {table_id});')1223 self.add_line("goto ERROR;")1224 self.end_block("}}")1225 if len(self.members) > 0:1226 self.add_line("const uint8_t *bitfield = buffer + bytes_read;")1227 self.add_line("bytes_read += {bitfield_byte_width};")1228 self.skip_line()1229 for member in self.members:1230 member.generate_c_deserialize(self)1231 self.add_line("return s;")1232 self.skip_line()1233 self.start_block("ERROR: {{")1234 self.add_line("{name}_free(s);")1235 self.add_line("return NULL;")1236 self.end_block("}}")1237 self.end_block("}}")1238 self.skip_line()1239 # Verify1240 self.start_block("bool {name}_verify(const uint8_t *buffer, size_t buffer_size) {{")1241 self.add_line("size_t bytes_read = 0;")1242 self.deserialize_c_varint("table_id", declare=True)1243 self.start_block("if (table_id != {table_id}) {{")1244 self.add_line("goto ERROR;")1245 self.end_block("}}")1246 self.add_line("return true;")1247 self.start_block("ERROR: {{")1248 self.add_line("return false;")1249 self.end_block("}}")1250 self.end_block("}}")1251 self.skip_line()1252 # Get/Sets1253 for member in self.members:1254 member.generate_get_set(self)1255 # Static Print1256 self.start_block("static void {name}_print_indent({name}_t *s, size_t indent) {{")1257 self.add_line('printf_indent(indent, "{name} {{\\n");')1258 self.add_line("indent += 1;")1259 for member in self.members:1260 member.generate_print(self)1261 self.add_line("indent -= 1;")1262 self.add_line('printf_indent(indent, "}}\\n");')1263 self.end_block("}}")1264 self.skip_line()1265 # Wrapper Print1266 self.start_block("void {name}_print({name}_t *s) {{")1267 self.add_line("{name}_print_indent(s, 0);")1268 self.end_block("}}")1269 1270 def generate_python(self):1271 """1272 Struct Definition1273 """1274 self.set_parameter("cls", self.name)1275 self.set_parameter("table_id", self.table_id)1276 self.set_parameter("bitfield_byte_width", (len(self.members) - 1) // 8 + 1)1277 self.start_block("class {cls}:")1278 self.add_line("__slots__ = [{}]".format(", ".join('"_{}"'.format(m.name) for m in self.members)))1279 self.skip_line()1280 parameters = ['self']1281 for member in self.members:1282 parameters.append(member.python_parameter)1283 self.start_block("def __init__({}):".format(1284 ", ".join(parameters)1285 ))1286 if not self.members:1287 self.add_line("pass")1288 for member in self.members:1289 self.set_parameter("field", member.name)1290 member.generate_python_initialize()1291 self.end_block()1292 self.skip_line()1293 self.start_block("def __repr__(self):")1294 self.add_line("values = []")1295 1296 for member in self.members:1297 self.set_parameter("field", member.name)1298 if member.vector and member.vector_size is None:1299 self.start_block("if len(self.{field}) > 0:")1300 else:1301 self.start_block("if self.{field} is not None:")1302 self.add_line("values.append('{field}=' + repr(self.{field}))")1303 self.end_block()1304 self.add_line("return '{cls}(' + ', '.join(values) + ')'")1305 self.end_block()1306 self.skip_line()1307 for member in self.members:1308 self.set_parameter("field", member.name)1309 self.set_parameter("python_type", member.python_type)1310 self.set_parameter("type_name", member.type.name)1311 self.set_parameter("vector_size", member.vector_size)1312 self.add_line("@property")1313 self.start_block("def {field}(self):")1314 if member.default is not None:1315 if member.type is Primitives.Boolean:1316 self.set_parameter("default", repr(bool(member.default)))1317 else:1318 self.set_parameter("default", repr(member.default))1319 self.start_block("if self._{field} is None:")1320 if isinstance(member.type, EnumDefinition):1321 self.add_line("return {type_name}({default})")1322 else:1323 self.add_line("return {default}")1324 self.end_block()1325 self.start_block("else:")1326 self.add_line("return self._{field}")1327 self.end_block()1328 else:1329 self.add_line("return self._{field}")1330 self.end_block()1331 self.skip_line()1332 self.add_line("@{field}.setter")1333 self.start_block("def {field}(self, value: {python_type}):")1334 if member.vector and member.vector_size:1335 self.start_block("if value is not None and len(value) != {vector_size}:")1336 self.add_line("raise ValueError('{cls}.{field} must be a list of fixed size: {vector_size}')")1337 self.end_block()1338 if not member.vector and isinstance(member.type, EnumDefinition):1339 self.start_block("if value is None:")1340 self.add_line("self._{field} = None")1341 self.end_block()1342 self.start_block("else:")1343 self.add_line("self._{field} = {type_name}(value)")1344 self.end_block()1345 else:1346 self.add_line("self._{field} = value")1347 self.end_block()1348 self.skip_line()1349 1350 self.start_block("def __eq__(self, other):")1351 self.start_block("if type(self) != type(other):")1352 self.add_line("return False")1353 self.end_block()1354 if self.members:1355 self.start_block("try:")1356 for member in self.members:1357 self.set_parameter("field", member.name)1358 self.start_block("if self._{field} != other._{field}:")1359 self.add_line("return False")1360 self.end_block()1361 self.end_block()1362 self.start_block("except AttributeError:")1363 self.add_line("return False")1364 self.end_block()1365 1366 self.add_line("return True")1367 self.end_block()1368 self.skip_line()1369 self.start_block("def serialize(self) -> bytes:")1370 self.add_line("buf = bytearray()")1371 if self.table_id > 0xFFFFFFFF:1372 table_id_bytes = "b'0xFF' + uint64({})".format(self.table_id)1373 elif self.table_id > 0xFFFF:1374 table_id_bytes = "b'0xFE' + uint32({})".format(self.table_id)1375 elif self.table_id >= 0xFD:1376 table_id_bytes = "b'0xFD' + uint16({})".format(self.table_id)1377 else:1378 table_id_bytes = "uint8({})".format(self.table_id)1379 self.add_line("buf.extend({})".format(table_id_bytes))1380 self.add_line("bitfield_index = len(buf)")1381 self.add_line("buf.extend(bytearray({bitfield_byte_width}))")1382 for member in self.members:1383 self.set_parameter("field", member.name)1384 if member.vector and member.vector_size is None:1385 self.start_block("if len(self._{field}) > 0:")1386 else:1387 self.start_block("if self._{field} is not None:")1388 self.add_line("buf[bitfield_index+{}] |= {}".format(1389 member.field_id // 8,1390 1 << (7 - member.field_id & 7)1391 ))1392 member.generate_python_serialize()1393 self.end_block()1394 self.add_line("return bytes(buf)")1395 self.end_block()1396 self.skip_line()1397 self.add_line("@classmethod")1398 self.start_block("def deserialize(cls, buf: Union[bytes, bytearray]) -> {cls}:")1399 self.add_line("buf_index = 0")1400 self.deserialize_py_varint("table_id")1401 self.start_block("if table_id != {table_id}:")1402 self.add_line("raise ValueError('Invalid table ID {{}}, expected {table_id}'.format(table_id))")1403 self.end_block()1404 self.add_line("table = cls()")1405 self.add_line("bitfield_index = buf_index")1406 self.set_parameter("bitfield_byte_width", (len(self.members) - 1) // 8 + 1)1407 self.add_line("buf_index += {bitfield_byte_width}")1408 for member in self.members:1409 self.set_parameter("field", member.name)1410 self.set_parameter("type_name", member.type.name)1411 member.generate_python_deserialize()1412 self.add_line("return table")1413 self.end_block()1414 self.end_block()1415 self.skip_line()1416 self.skip_line()1417class TableDefinition(StructDefinition):1418 pass1419@dataclass1420class EnumDefinition(SchemaElement):1421 schema: Schema1422 name: str1423 members: List[EnumMember] = field(default_factory=list)1424 size: Union[Primitives.Int8, Primitives.UInt8] = 'uint16'1425 next_value: int = 01426 values: Set[int] = field(default_factory=set)1427 @property1428 def c_name(self):1429 return "{}_e".format(self.name)1430 def resolve_types(self, schema):1431 self.size = BUILTIN_TYPES.get(self.size, self.size)1432 if self.size not in INTEGER_PRIMITIVES:1433 raise TypeError("the type of an enum definition must be an integer primitive, not '{}'".format(self.size))1434 for enum_member in self.members:1435 enum_member.resolve_value(self)1436 def validate(self):1437 pass1438 def generate_typedefs(self):1439 self.set_parameter("name", self.name)1440 self.start_block("typedef enum {name}_e {{")1441 for member, end in join_iterate(self.members):1442 line = "{} = {}".format(member.name, member.value)1443 if not end:1444 line += ','1445 self.add_line(line)1446 self.end_block("}} {name}_e;")1447 def generate_python(self):1448 """1449 Enum Definition1450 """1451 self.set_parameter("cls", self.name)1452 self.start_block("class {cls}(IntEnum):")1453 for member in self.members:1454 self.add_line("{} = {}".format(member.name, member.value))1455 self.end_block()1456 self.skip_line()1457 self.skip_line()1458@dataclass1459class Schema:1460 definitions: Dict[str, Union[EnumDefinition, StructDefinition, TableDefinition]]1461 name: str = "ANONYMOUS_SCHEMA"1462 next_table_id: int = 11463 indentation: str = ' '1464 indentation_level: int = 01465 current_output: List[str] = field(default_factory=list)1466 format_parameters: Dict[str, str] = field(default_factory=dict)1467 format_parameters_stack: List[Dict[str, str]] = field(default_factory=list)1468 debug: bool = False1469 def add_c_comment(self, comment="", **kwargs):1470 self.add_comment(comment, opener="/**", line_start=" *", closer=" */", **kwargs)1471 def add_py_comment(self, comment="", **kwargs):1472 self.add_comment(comment, opener="\"\"\"", line_start=" ", closer="\"\"\"", **kwargs)1473 def add_comment(self, comment="", *, return_comment=None, opener, line_start, closer, **kwargs):1474 self.add_line(opener)1475 if comment:1476 for line in textwrap.wrap(re.sub('\s+', ' ', comment.strip()), width=80):1477 self.add_line(line_start + " " + line)1478 self.add_line(line_start)1479 for param, comment in kwargs.items():1480 padding_length = len(param) + len("@param ")1481 for i, line in enumerate(textwrap.wrap(re.sub('\s+', ' ', comment.strip()), width=80)):1482 if i == 0:1483 self.add_line("{} @param {} {}".format(line_start, param, line))1484 else:1485 self.add_line("{} {} {}".format(line_start, " " * padding_length, line))1486 self.add_line(line_start)1487 if return_comment:1488 for i, line in enumerate(textwrap.wrap(re.sub('\s+', ' ', return_comment.strip()), width=80)):1489 if i == 0:1490 self.add_line("{} @return {}".format(line_start, line))1491 else:1492 self.add_line("{} {}".format(line_start, line))1493 else:1494 self.pop_line()1495 self.add_line(closer)1496 1497 def serialize_py_varint(self, expr: str):1498 self.start_block("if {} > 0xFFFFFFFF:".format(expr))1499 self.add_line("buf.extend(uint8(0xFF))")1500 self.add_line("buf.extend(uint64({}))".format(expr))1501 self.end_block()1502 self.start_block("elif {} > 0xFFFF:".format(expr))1503 self.add_line("buf.extend(uint8(0xFE))")1504 self.add_line("buf.extend(uint32({}))".format(expr))1505 self.end_block()1506 self.start_block("elif {} >= 0xFD:".format(expr))1507 self.add_line("buf.extend(uint8(0xFD))")1508 self.add_line("buf.extend(uint16({}))".format(expr))1509 self.end_block()1510 self.start_block("else:")1511 self.add_line("buf.extend(uint8({}))".format(expr))1512 self.end_block()1513 def c_allocate(self, expr: Union[str, int]):1514 self.add_line("allocate_space(&buffer, &buffer_size, bytes_written, {});".format(expr))1515 def serialize_c_varint(self, expr: str):1516 self.add_line("serialize_varint(&buffer, buffer_size, &bytes_written, {});".format(expr))1517 def deserialize_py_varint(self, name: str):1518 self.add_line("specifier = buf[buf_index]")1519 self.add_line("buf_index += 1")1520 self.start_block("if specifier == 0xFF:")1521 self.add_line("{} = unsigned_int(buf[buf_index:buf_index+8])".format(name))1522 self.add_line("buf_index += 8")1523 self.end_block()1524 self.start_block("elif specifier == 0xFE:")1525 self.add_line("{} = unsigned_int(buf[buf_index:buf_index+4])".format(name))1526 self.add_line("buf_index += 4")1527 self.end_block()1528 self.start_block("elif specifier == 0xFD:")1529 self.add_line("{} = unsigned_int(buf[buf_index:buf_index+2])".format(name))1530 self.add_line("buf_index += 2")1531 self.end_block()1532 self.start_block("else:")1533 self.add_line("{} = specifier".format(name))1534 self.end_block()1535 def deserialize_c_int(self, name: str, size: int, *, declare: bool = False, signed: bool = False):1536 self.start_block("if (bytes_read + {} > buffer_size) {{{{".format(size))1537 self.add_line("goto ERROR;")1538 self.end_block("}}")1539 ctype = "{}int{}_t".format("" if signed else "u", size * 8)1540 if size in (2,4,8):1541 converter = "be{}toh".format(size * 8)1542 else:1543 converter = ""1544 if declare:1545 self.add_line("{} {} = {}(*({}*)(buffer+bytes_read));".format(ctype, name, converter, ctype))1546 else:1547 self.add_line("{} = {}(*({}*)(buffer+bytes_read));".format(name, converter, ctype))1548 self.add_line("bytes_read += {};".format(size))1549 def deserialize_c_varint(self, name: str, *, declare: bool = False):1550 if declare:1551 self.add_line("size_t {} = parse_varint(buffer, buffer_size, &bytes_read);".format(name))1552 else:1553 self.add_line("{} = parse_varint(buffer, buffer_size, &bytes_read);".format(name))1554 self.start_block("if ({} == SIZE_MAX) {{{{".format(name))1555 self.add_line("goto ERROR;")1556 self.end_block("}}")1557 1558 def set_parameter(self, key, value):1559 self.format_parameters[key] = value1560 def push_parameters(self):1561 self.format_parameters_stack.append(self.format_parameters.copy())1562 def pop_parameters(self):1563 self.format_parameters = self.format_parameters_stack.pop()1564 def add_debug(self, code=None):1565 if self.debug:1566 self.add_line(code)1567 def add_line(self, code=None):1568 if code:1569 self.current_output.append(1570 self.indentation * self.indentation_level + code.format(**self.format_parameters)1571 )1572 else:1573 self.current_output.append('')1574 def pop_line(self):1575 return self.current_output.pop()1576 def skip_line(self, count=1):1577 for i in range(count):1578 self.current_output.append('')1579 def start_block(self, code=""):1580 if code:1581 self.add_line(code)1582 self.indentation_level += 11583 def end_block(self, code=""):1584 self.indentation_level -= 11585 if code:1586 self.add_line(code)1587 def output(self):1588 result = "\n".join(self.current_output) + "\n"1589 self.current_output = []1590 return result1591 @property1592 def structs(self):1593 return (d for d in self.definitions.values() if not isinstance(d, EnumDefinition))1594 def resolve_types(self):1595 for definition in self.definitions.values():1596 definition.resolve_types(self)1597 1598 for definition in self.structs:1599 definition.table_id = self.next_table_id1600 self.next_table_id += 11601 next_field_id = 01602 for member in definition.members:1603 member.field_id = next_field_id1604 next_field_id += 11605 def validate(self):1606 for definition in self.definitions.values():1607 definition.validate()1608 def generate_c_header(self):1609 self.set_parameter("schema_name", self.name.lower())1610 self.add_line("#ifndef _SERIALIB_{schema_name}_H")1611 self.add_line("#define _SERIALIB_{schema_name}_H")1612 self.skip_line()1613 self.add_line("#include <stdint.h>")1614 self.add_line("#include <stdbool.h>")1615 self.add_line("#include <stdlib.h>")1616 self.skip_line()1617 self.start_block("typedef enum TableType_e {{")1618 self.add_line("TABLE_TYPE_INVALID = 0,")1619 for definition, end in join_iterate(self.structs):1620 self.set_parameter("table_name", definition.name)1621 self.set_parameter("table_id", definition.table_id)1622 if end:1623 self.add_line("TABLE_TYPE_{table_name} = {table_id}")1624 else:1625 self.add_line("TABLE_TYPE_{table_name} = {table_id},")1626 self.end_block("}} TableType_e;")1627 self.skip_line()1628 for definition in self.definitions.values():1629 definition.generate_typedefs()1630 self.skip_line()1631 try:1632 example_definition = next(iter(self.structs))1633 self.set_parameter("example", example_definition.name)1634 self.add_c_comment(1635 comment="""1636 Checks a buffer that has been serialized with one of the <table/struct>_serialize() functions1637 and returns the TableType_e that corresponds with the table used to create the buffer.1638 For example, if {example}_serialize() was used to create the buffer, this function will return1639 TABLE_TYPE_{example}. If the buffer cannot be any of the known tables, TABLE_TYPE_INVALID is1640 returned instead.1641 """1642 )1643 self.add_line("TableType_e determine_table_type(const uint8_t *buffer, size_t buffer_size);")1644 self.skip_line()1645 except StopIteration:1646 pass1647 for definition in self.structs:1648 definition.generate_signatures()1649 self.skip_line()1650 self.add_line("#endif")1651 return self.output()1652 def generate_c_source(self, header_path):1653 self.set_parameter("schema_name", self.name.lower())1654 self.set_parameter("header_path", header_path)1655 self.add_line("#include <stdint.h>")1656 self.add_line("#include <stdbool.h>")1657 self.add_line("#include <stdlib.h>")1658 self.add_line("#include <string.h>")1659 self.add_line("#include <endian.h>")1660 self.add_line("#include <stdarg.h>")1661 self.add_line("#include <stdio.h>")1662 self.add_line("#include \"{header_path}\"")1663 self.skip_line()1664 self.start_block("static void printf_indent(size_t indent, const char *fmt, ...) {{")1665 self.start_block("for (size_t i = 0; i < indent; i++) {{")1666 self.add_line('printf(" ");')1667 self.end_block("}}")1668 self.add_line("va_list va_args;")1669 self.add_line("va_start(va_args, fmt);")1670 self.add_line("vprintf(fmt, va_args);")1671 self.add_line("va_end(va_args);")1672 self.end_block("}}")1673 self.skip_line()1674 self.start_block("static void allocate_space(uint8_t **buffer, size_t *buffer_size, size_t bytes_written, size_t bytes_needed) {{")1675 self.start_block("while (bytes_written + bytes_needed > *buffer_size) {{")1676 self.add_line("*buffer_size *= 2;")1677 self.end_block("}}")1678 self.add_line("*buffer = realloc(*buffer, *buffer_size);")1679 self.end_block("}}")1680 self.skip_line()1681 self.start_block("static void serialize_varint(uint8_t **buffer_ptr, size_t buffer_size, size_t *bytes_written_ptr, size_t value) {{")1682 self.add_line("uint8_t *buffer = *buffer_ptr;")1683 self.add_line("size_t bytes_written = *bytes_written_ptr;")1684 self.start_block("if (value > 0xFFFFFFFF) {{")1685 self.c_allocate(9)1686 self.add_line("((uint8_t*)(buffer + bytes_written))[0] = 0xFF;")1687 self.add_line("bytes_written += 1;")1688 self.add_line("((uint64_t*)(buffer + bytes_written))[0] = htobe64((uint64_t)(value));")1689 self.add_line("bytes_written += 8;")1690 self.end_block("}}")1691 self.start_block("else if (value > 0xFFFF) {{")1692 self.c_allocate(5)1693 self.add_line("((uint8_t*)(buffer + bytes_written))[0] = 0xFE;")1694 self.add_line("bytes_written += 1;")1695 self.add_line("((uint32_t*)(buffer + bytes_written))[0] = htobe32((uint32_t)(value));")1696 self.add_line("bytes_written += 4;")1697 self.end_block("}}")1698 self.start_block("else if (value >= 0xFD) {{")1699 self.c_allocate(3)1700 self.add_line("((uint8_t*)(buffer + bytes_written))[0] = 0xFD;")1701 self.add_line("bytes_written += 1;")1702 self.add_line("((uint16_t*)(buffer + bytes_written))[0] = htobe16((uint16_t)(value));")1703 self.add_line("bytes_written += 2;")1704 self.end_block("}}")1705 self.start_block("else {{")1706 self.c_allocate(1)1707 self.add_line("((uint8_t*)(buffer + bytes_written))[0] = (uint8_t)(value);")1708 self.add_line("bytes_written += 1;")1709 self.end_block("}}")1710 self.add_line("*bytes_written_ptr = bytes_written;")1711 self.add_line("*buffer_ptr = buffer;")1712 self.end_block("}}")1713 self.start_block("static size_t parse_varint(const uint8_t *buffer, size_t buffer_size, size_t *bytes_read_ptr) {{")1714 self.add_line("size_t bytes_read = *bytes_read_ptr;")1715 self.start_block("if (bytes_read + 1 > buffer_size) {{")1716 self.add_line("goto ERROR;")1717 self.end_block("}}")1718 self.add_line("size_t value;")1719 self.start_block("if (buffer[bytes_read] == 0xFF) {{")1720 self.add_line("bytes_read += 1;")1721 self.deserialize_c_int("value", 8)1722 self.end_block("}}")1723 self.start_block("else if (buffer[bytes_read] == 0xFE) {{")1724 self.add_line("bytes_read += 1;")1725 self.deserialize_c_int("value", 4)1726 self.end_block("}}")1727 self.start_block("else if (buffer[bytes_read] == 0xFD) {{")1728 self.add_line("bytes_read += 1;")1729 self.deserialize_c_int("value", 2)1730 self.end_block("}}")1731 self.start_block("else {{")1732 self.deserialize_c_int("value", 1)1733 self.end_block("}}")1734 self.add_line("*bytes_read_ptr = bytes_read;")1735 self.add_line("return value;")1736 self.add_line("ERROR:")1737 self.add_line("*bytes_read_ptr = bytes_read;")1738 self.add_line("return SIZE_MAX;")1739 self.end_block("}}")1740 self.skip_line()1741 self.set_parameter("NUM_TABLE_IDS", self.next_table_id)1742 self.start_block("TableType_e determine_table_type(const uint8_t *buffer, size_t buffer_size) {{")1743 self.add_line("size_t bytes_read = 0;")1744 self.deserialize_c_varint("table_id", declare=True)1745 self.start_block("if (table_id >= {NUM_TABLE_IDS}) {{")1746 self.add_line("goto ERROR;")1747 self.end_block("}}")1748 self.add_line("return (TableType_e)table_id;")1749 self.start_block("ERROR: {{")1750 self.add_line("return TABLE_TYPE_INVALID;")1751 self.end_block("}}")1752 self.end_block("}}")1753 self.skip_line()1754 for definition in self.structs:1755 definition.generate_c_source()1756 return self.output()1757 def generate_python(self):1758 """1759 Schema1760 """1761 self.add_line("from __future__ import annotations")1762 self.add_line("from dataclasses import dataclass, field")1763 self.add_line("from enum import IntEnum")1764 self.add_line("from typing import Union, List, Optional")1765 self.skip_line(2)1766 self.start_block("def uint8(value):")1767 self.add_line("return value.to_bytes(1, 'big', signed=False)")1768 self.end_block()1769 self.skip_line(2)1770 self.start_block("def uint16(value):")1771 self.add_line("return value.to_bytes(2, 'big', signed=False)")1772 self.end_block()1773 self.skip_line(2)1774 self.start_block("def uint32(value):")1775 self.add_line("return value.to_bytes(4, 'big', signed=False)")1776 self.end_block()1777 self.skip_line(2)1778 self.start_block("def uint64(value):")1779 self.add_line("return value.to_bytes(8, 'big', signed=False)")1780 self.end_block()1781 self.skip_line(2)1782 self.start_block("def int8(value):")1783 self.add_line("return value.to_bytes(1, 'big', signed=True)")1784 self.end_block()1785 self.skip_line(2)1786 self.start_block("def int16(value):")1787 self.add_line("return value.to_bytes(2, 'big', signed=True)")1788 self.end_block()1789 self.skip_line(2)1790 self.start_block("def int32(value):")1791 self.add_line("return value.to_bytes(4, 'big', signed=True)")1792 self.end_block()1793 self.skip_line(2)1794 self.start_block("def int64(value):")1795 self.add_line("return value.to_bytes(8, 'big', signed=True)")1796 self.end_block()1797 self.skip_line(2)1798 self.start_block("def unsigned_int(buf):")1799 self.add_line("return int.from_bytes(buf, 'big', signed=False)")1800 self.end_block()1801 self.skip_line(2)1802 self.start_block("def signed_int(buf):")1803 self.add_line("return int.from_bytes(buf, 'big', signed=True)")1804 self.end_block()1805 self.skip_line(2)1806 for definition in self.definitions.values():1807 definition.generate_python()1808 self.start_block("TABLE_ID_MAP = {{")1809 for definition in self.structs:1810 self.add_line("{}: {},".format(definition.table_id, definition.name))1811 self.end_block("}}")1812 self.skip_line(2)1813 self.start_block("def deserialize(buf: Union[bytes, bytearray]):")1814 self.add_line("buf_index = 0")1815 self.deserialize_py_varint("table_id")1816 self.start_block("try:")1817 self.add_line("cls = TABLE_ID_MAP[table_id]")1818 self.end_block()1819 self.start_block("except KeyError:")1820 self.add_line("raise ValueError('Unrecognized Table ID')")1821 self.end_block()1822 self.add_line("return cls.deserialize(buf)")1823 self.end_block()1824 return self.output()1825def main():1826 import argparse1827 parser = argparse.ArgumentParser()1828 parser.add_argument('schema', type=Path)1829 parser.add_argument('--python', type=Path, default=None)1830 parser.add_argument('--c-source', type=Path, default=None)1831 parser.add_argument('--c-header', type=Path, default=None)1832 args = parser.parse_args()1833 # Read schema file1834 with open(args.schema, "r") as f:1835 text_schema = f.read()1836 # Lex and parse schema...
banner.py
Source:banner.py
...307################################################################################308# Writing the lines corresponding to the cuts309################################################################################310 311 self.add_line('maxjetflavor', 'int', 4)312 self.add_line('auto_ptj_mjj', 'bool', True)313 self.add_line('cut_decays', 'bool', True)314 # minimum pt315 self.add_line('ptj', 'float', 20)316 self.add_line('ptb', 'float', 20)317 self.add_line('pta', 'float', 20)318 self.add_line('ptl', 'float', 20)319 self.add_line('misset', 'float', 0)320 self.add_line('ptonium', 'float', 0.0)321 # maximal pt322 self.add_line('ptjmax', 'float', -1)323 self.add_line('ptbmax', 'float', -1)324 self.add_line('ptamax', 'float', -1)325 self.add_line('ptlmax', 'float', -1)326 self.add_line('missetmax', 'float', -1)327 # maximal rapidity (absolute value)328 self.add_line('etaj', 'float', 4.0)329 self.add_line('etab', 'float', 4.0)330 self.add_line('etaa', 'float', 4.0)331 self.add_line('etal', 'float', 4.0)332 # minimal rapidity (absolute value)333 self.add_line('etajmin', 'float', 0.0)334 self.add_line('etabmin', 'float', 0.0)335 self.add_line('etaamin', 'float', 0.0)336 self.add_line('etalmin', 'float', 0.0)337 self.add_line('etaonium', 'float', 100.0)338 # Minimul E's339 self.add_line('ej', 'float', 0.0)340 self.add_line('eb', 'float', 0.0)341 self.add_line('ea', 'float', 0.0)342 self.add_line('el', 'float', 0.0)343 # Maximum E's344 self.add_line('ejmax', 'float', -1)345 self.add_line('ebmax', 'float', -1)346 self.add_line('eamax', 'float', -1)347 self.add_line('elmax', 'float', -1) 348 # minimum delta_r349 self.add_line('drjj', 'float', 0.4) 350 self.add_line('drbb', 'float', 0.4) 351 self.add_line('drll', 'float', 0.4) 352 self.add_line('draa', 'float', 0.4) 353 self.add_line('drbj', 'float', 0.4) 354 self.add_line('draj', 'float', 0.4) 355 self.add_line('drjl', 'float', 0.4) 356 self.add_line('drab', 'float', 0.4) 357 self.add_line('drbl', 'float', 0.4) 358 self.add_line('dral', 'float', 0.4) 359 # maximum delta_r360 self.add_line('drjjmax', 'float', -1)361 self.add_line('drbbmax', 'float', -1)362 self.add_line('drllmax', 'float', -1)363 self.add_line('draamax', 'float', -1)364 self.add_line('drbjmax', 'float', -1)365 self.add_line('drajmax', 'float', -1)366 self.add_line('drjlmax', 'float', -1)367 self.add_line('drabmax', 'float', -1)368 self.add_line('drblmax', 'float', -1)369 self.add_line('dralmax', 'float', -1)370 # minimum invariant mass for pairs371 self.add_line('mmjj', 'float', 0.0)372 self.add_line('mmbb', 'float', 0.0)373 self.add_line('mmaa', 'float', 0.0)374 self.add_line('mmll', 'float', 0.0)375 # maximum invariant mall for pairs376 self.add_line('mmjjmax', 'float', -1)377 self.add_line('mmbbmax', 'float', -1)378 self.add_line('mmaamax', 'float', -1)379 self.add_line('mmllmax', 'float', -1)380 #Min Maxi invariant mass for all leptons 381 self.add_line("mmnl", 'float', 0.0)382 self.add_line("mmnlmax", 'float', -1)383 #inclusive cuts384 self.add_line("xptj", 'float', 0.0)385 self.add_line("xptb", 'float', 0.0)386 self.add_line("xpta", 'float', 0.0)387 self.add_line("xptl", 'float', 0.0)388 self.add_line("xmtcentral", 'float', 0.0, fortran_name='xmtc', log=10)389 # WBT cuts390 self.add_line("xetamin", 'float', 0.0)391 self.add_line("deltaeta", 'float', 0.0)392 # Jet measure cuts 393 self.add_line("xqcut", 'float', 0.0)394 self.add_line("d", 'float', 1.0, log=10)395 # Set min pt of one heavy particle 396 self.add_line("ptheavy", 'float', 0.0)397 # Pt of pairs of leptons (CHARGED AND NEUTRALS)398 self.add_line("ptllmin", "float", 0.0)399 self.add_line("ptllmax", "float", -1)400 # Check the pt's of the jets sorted by pt401 self.add_line("ptj1min", "float", 0.0)402 self.add_line("ptj1max", "float", -1)403 self.add_line("ptj2min", "float", 0.0)404 self.add_line("ptj2max", "float", -1)405 self.add_line("ptj3min", "float", 0.0)406 self.add_line("ptj3max", "float", -1)407 self.add_line("ptj4min", "float", 0.0)408 self.add_line("ptj4max", "float", -1)409 self.add_line("cutuse", "float", 0.0)410 # Check the pt's of leptons sorted by pt411 self.add_line("ptl1min", "float", 0.0)412 self.add_line("ptl1max", "float", -1)413 self.add_line("ptl2min", "float", 0.0)414 self.add_line("ptl2max", "float", -1)415 self.add_line("ptl3min", "float", 0.0)416 self.add_line("ptl3max", "float", -1)417 self.add_line("ptl4min", "float", 0.0)418 self.add_line("ptl4max", "float", -1)419 # Check Ht420 self.add_line("ht2min", 'float', 0.0)421 self.add_line("ht3min", 'float', 0.0)422 self.add_line("ht4min", 'float', 0.0)423 self.add_line("ht2max", 'float', -1)424 self.add_line("ht3max", 'float', -1)425 self.add_line("ht4max", 'float', -1) 426 self.add_line("htjmin", 'float', 0.0)427 self.add_line("htjmax", 'float', -1) 428 self.add_line("ihtmin", 'float', 0.0)429 self.add_line("ihtmax", 'float', -1)430################################################################################431# Writing the lines corresponding to anything but cuts432################################################################################433 # seed434 self.add_line("gridpack","bool", False)435 self.add_line("gridrun",'bool', False, log=10)436 if str(self['gridrun']) in ['1','T','.true','True'] and \437 str(self['gridpack']) in ['1','T','.true','True']:438 self.add_line('gseed', 'int', 0, fortran_name='iseed')439 else:440 self.add_line('iseed', 'int', 0, fortran_name='iseed')441 # Renormalizrion and factorization scales442 self.add_line('fixed_ren_scale', 'bool', True)443 self.add_line('fixed_fac_scale', 'bool', True)444 self.add_line('scale', 'float', 'float', 91.188)445 self.add_line('dsqrt_q2fact1','float', 91.188, fortran_name='sf1')446 self.add_line('dsqrt_q2fact2', 'float', 91.188, fortran_name='sf2')447 self.add_line('scalefact', 'float', 1.0)448 self.add_line('fixed_couplings', 'bool', True, log=10)449 self.add_line('ickkw', 'int', 0)450 self.add_line('chcluster', 'bool', False)451 self.add_line('ktscheme', 'int', 1)452 self.add_line('asrwgtflavor', 'int', 5)453 if int(self['ickkw'])>0:454 self.add_line('alpsfact', 'float', 1.0)455 self.add_line('pdfwgt', 'bool', True)456 if int(self['ickkw'])==2:457 self.add_line('highestmult','int', 0, fortran_name='nhmult')458 self.add_line('issgridfile','str','issudgrid.dat')459 # Collider energy and type460 self.add_line('lpp1', 'int', 1, fortran_name='lpp(1)')461 self.add_line('lpp2', 'int', 1, fortran_name='lpp(2)')462 self.add_line('ebeam1', 'float', 7000, fortran_name='ebeam(1)')463 self.add_line('ebeam2', 'float', 7000, fortran_name='ebeam(2)')464 # Beam polarization465 self.add_line('polbeam1', 'float', 0.0, fortran_name='pb1')466 self.add_line('polbeam2', 'float', 0.0, fortran_name='pb2')467 # BW cutoff (M+/-bwcutoff*Gamma)468 self.add_line('bwcutoff', 'float', 15.0)469 # Collider pdf470 self.add_line('pdlabel','str','cteq6l1')471 if self['pdlabel'] == 'lhapdf':472 self.add_line('lhaid', 'int', 10042)473 else:474 self.add_line('lhaid', 'int', 10042, log=10)475 476 self.fsock.close()477 478 def add_line(self, card_name, type, default, log=30, fortran_name=None):479 """get the line for the .inc file""" 480 481 value = self.get_default(card_name, default, log)482 if not fortran_name:483 fortran_name = card_name484 self.fsock.writelines(' %s = %s \n' % (fortran_name, self.format(type, value)))...
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run pytest-bdd automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
