def output_values_to_gci(self): output_bits = [] # Since Field.values is an OrderedDict, this should work for getting # values in order. for field_key, field_value in Field.values.items(): field = Field.field_lookup[field_key] output_bits.extend(field.value_to_bits(field_value)) bits = [] byte_array = [] for bit in output_bits: bits.append(bit) if len(bits) == 8: bits.reverse() byte_array.append(Field.eight_bits_to_byte(bits)) bits = [] # Add remaining bits, if any if bits: bits.reverse() # Pad with 0s on left to get 8 bits total bits = (['0'] * (8 - len(bits))) + bits byte_array.append(Field.eight_bits_to_byte(bits)) return byte_array
def __init__(self, to, to_field=None, rel_class=ListRelation, **kwargs): contains_built_in_type = False try: to_name = to._meta.object_name.lower() except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT # to._meta doesn't exist is it a basic type if is_accepted_type(to): contains_built_in_type = True #assert isinstance(to, basestring), "%s(%r) is invalid. First parameter to ForeignKey must be either a model, a model name, or the string %r" % (self.__class__.__name__, to, RECURSIVE_RELATIONSHIP_CONSTANT) else: #assert not to._meta.abstract, "%s cannot define a relation with abstract class %s" % (self.__class__.__name__, to._meta.object_name) # For backwards compatibility purposes, we need to *try* and set # the to_field during FK construction. It won't be guaranteed to # be correct until contribute_to_class is called. Refs #12190. to_field = to_field kwargs['verbose_name'] = kwargs.get('verbose_name', None) kwargs['rel'] = rel_class(self, to, to_field, related_name=kwargs.pop('related_name', None), limit_choices_to=kwargs.pop('limit_choices_to', None), lookup_overrides=kwargs.pop('lookup_overrides', None), parent_link = False, xml_element_name = kwargs.get('xml_element_name', 'item'), contains_built_in_type = contains_built_in_type) Field.__init__(self, **kwargs) if self.min_length is not None: self.validators.append(MinListLengthValidator(self.min_length)) if self.max_length is not None: self.validators.append(MaxListLengthValidator(self.max_length))
class DNSQR(Proto): name = "DNS Question Record" fields = { "qname": Field("qname"), "qtype": Field("qtype"), "qclass": Field("qclass") }
def __init__(self, queryset, empty_label=u"---------", cache_choices=False, required=True, widget=None, label=None, initial=None, help_text=None, to_field_name=None, *args, **kwargs): if required and (initial is not None): self.empty_label = None else: self.empty_label = empty_label self.cache_choices = cache_choices # Call Field instead of ChoiceField __init__() because we don't need # ChoiceField.__init__(). Field.__init__(self, required, widget, label, initial, help_text, *args, **kwargs) self.queryset = queryset self.choice_cache = None self.to_field_name = to_field_name
def __init__( self, queryset, empty_label=u"---------", cache_choices=False, required=True, widget=None, label=None, initial=None, help_text=None, to_field_name=None, *args, **kwargs ): if required and (initial is not None): self.empty_label = None else: self.empty_label = empty_label self.cache_choices = cache_choices # Call Field instead of ChoiceField __init__() because we don't need # ChoiceField.__init__(). Field.__init__(self, required, widget, label, initial, help_text, *args, **kwargs) self.queryset = queryset self.choice_cache = None self.to_field_name = to_field_name
def __init__(self): Field.__init__(self) scriptList.register(self) from kivy.app import App def inner(*args): self.stack = App.get_running_app().root.ids['deck'].ids['stack'] from kivy.clock import Clock Clock.schedule_once(inner,1)
def test_byte_place_out_of_byte(self): # trying to place a field that will not be contained in the current byte # should return false and leave the byte unaffected b = Byte() self.assertFalse(b.place(Field("f3", 4), 11)) self.assertFalse(b.place(Field("f3", 4), -1)) self.assertTrue(isinstance(b.fields, list)) self.assertEqual(len(b.fields), 0)
class DNSRR(Proto): name = "DNS Resource Record" fields = { "rrname": Field("rrname"), "type": Field("type"), "ttl": Field("ttl"), "rclass": Field("rclass") }
def clean(self, value): Field.clean(self, value) if value in EMPTY_VALUES: return None try: value = self.queryset.get(pk=value) except self.queryset.model.DoesNotExist: raise ValidationError(self.error_messages['invalid_choice']) return value
class TCP(Proto): name = "TCP" fields = { "sport": Field("sport"), "dport": Field("dport"), "seq": Field("seq"), "ack": Field("ack"), "window": Field("window") }
def func_params(field_node): field = Field() if field_node.args: field['args'] = Resolver.resolve(field_node.args) field.update(**Resolver.keywords(field_node.keywords)) return field
def __init__(self, queryset, empty_label=u"---------", cache_choices=False, required=True, widget=Select, label=None, initial=None, help_text=None): self.queryset = queryset self.empty_label = empty_label self.cache_choices = cache_choices # Call Field instead of ChoiceField __init__() because we don't need # ChoiceField.__init__(). Field.__init__(self, required, widget, label, initial, help_text) self.widget.choices = self.choices
def clean(self, value): Field.clean(self, value) if value in ('', None): return None try: value = self.queryset.model._default_manager.get(pk=value) except self.queryset.model.DoesNotExist: raise ValidationError(gettext(u'Select a valid choice. That choice is not one of the available choices.')) return value
def test_field_place(self): f = Field("test", 4) # place Field in single byte, msb = f.size - 1 = 3 (=> lsb should be 0) b0 = Byte() self.assertTrue(f.place(b0, 3)) # now the field should have all placement information self.assertEqual(len(f.bytes), 1) self.assertEqual(f.bytes[0], b0) self.assertEqual(f.msb, 3) self.assertEqual(f.lsb, 0)
def test_marshal(self): b = Byte() f = Field("test", 4) self.assertTrue(f.place(b, 3)) # for marshalling we need the bytes, not the field self.assertRaises(AssertionError, self.cg.marshal, f) self.assertEqual(self.cg.marshal(b), "data[ 0] = (pre->test << 0);") self.assertTrue(Field("test2", 2).place(b, 5)) self.assertEqual(self.cg.marshal(b), "data[ 0] = (pre->test2 << 4) | (pre->test << 0);")
def test_multibyte_unmarshal(self): bytes = [Byte(ii) for ii in range(0, 5)] f = Field("big", 32) self.assertTrue(f.place(bytes, (len(bytes) * 8) - 1 - 4)) self.assertEqual( self.cg.unmarshal(f), "pre->big = ((data[ 0] >> 0) & 0x0f) << 28 | ((data[ 1] >> 0) & 0xff) << 20" + " | ((data[ 2] >> 0) & 0xff) << 12 | ((data[ 3] >> 0) & 0xff) << 4" + " | ((data[ 4] >> 4) & 0x0f) << 0;")
def clean(self, value): Field.clean(self, value) if value in ('', None): return None try: value = self.queryset.model._default_manager.get(pk=value) except self.queryset.model.DoesNotExist: raise ValidationError( gettext( u'Select a valid choice. That choice is not one of the available choices.' )) return value
def clean(self, value): Field.clean(self, value) if value in EMPTY_VALUES: return None if self.to_field_name: value = deepcopy(self.queryset).filter(self.to_field_name + ' =', value).get() else: value = self.queryset.model.get(value) if not value: raise ValidationError(self.error_messages['invalid_choice']) return value
def test_multibyte_marshal(self): bytes = [Byte(ii) for ii in range(0, 5)] f = Field("big", 32) self.assertTrue(f.place(bytes, (len(bytes) * 8) - 1 - 4)) self.assertEqual(self.cg.marshal(bytes[0]), "data[ 0] = (pre->big >> 28);") self.assertEqual(self.cg.marshal(bytes[1]), "data[ 1] = (pre->big >> 20);") self.assertEqual(self.cg.marshal(bytes[2]), "data[ 2] = (pre->big >> 12);") self.assertEqual(self.cg.marshal(bytes[3]), "data[ 3] = (pre->big >> 4);") self.assertEqual(self.cg.marshal(bytes[4]), "data[ 4] = (pre->big << 4);")
def process_input_gci(self): self.input_gci_label.setText("Working...") self.input_gci = gci(self.input_gci_filepath) input_data = self.input_gci.get_replay_data() Field.reset_field_structures() success = self.gci_fields_widget.read_fields_from_spec() if not success: self.input_gci_label.setText("Drag and drop a .gci to get started") return # Process the replay-specific GCI contents. # This call can take a while, especially with custom machines. self.run_worker_job( functools.partial(self.gci_fields_widget.read_values_from_gci, input_data))
def process_fields(self, fields=None): for field_def in fields: field_name = field_def.get("fieldName") if not self.is_duplicate_field_name(field_name): raise Exception("Form definition problem : field name issue") field = Field(**field_def, form=self) self.fields[field_name] = field return
def tryGetField(f): """Try getting the field from the input. The method will return the input if it is an instance of class <Field>, otherwise it tries to create the field from a dictionary and finally tries to create it from the string. """ if isinstance(f, Field): return f elif isinstance(f, (dict, OrderedDict)): return Field.fromDict(f) else: try: return Field.fromString(f) except Exception: raise ValueError( 'Failed to create an OpenFOAM field from {}. Use a valid value.' .format(f))
def test_field_defaults(self): f = Field("test", 4) self.assertEqual(f.name, "test") self.assertEqual(f.size, 4) # in bits # position is yet undefined self.assertTrue(isinstance(f.bytes, list)) self.assertEqual(len(f.bytes), 0) # most and least significant bit definitions # relative to first/last byte in list # if field does not have a position, these should be -1 self.assertEqual(f.msb, -1) self.assertEqual(f.lsb, -1) # byte relative msb/lsb are only defined for bytes that the field # is placed in self.assertEqual(f.msb_in_byte(Byte()), -1) self.assertEqual(f.lsb_in_byte(Byte()), -1)
def value_to_string(self, obj): if not obj: # In required many-to-one fields with only one available choice, # select that one available choice. Note: For SelectFields # we have to check that the length of choices is *2*, not 1, # because SelectFields always have an initial "blank" value. if not self.blank and self.choices: choice_list = self.get_choices_default() if len(choice_list) == 2: return smart_unicode(choice_list[1][0]) return Field.value_to_string(self, obj)
def test_byte_can_place(self): b = Byte() f0 = Field("f0", 4) self.assertTrue(b.can_place(f0, 3)) # byte remaons unaffected self.assertEqual(len(b.fields), 0) # field remains unaffected self.assertEqual(f0.msb, -1) self.assertEqual(f0.lsb, -1) self.assertEqual(f0.size, 4) self.assertEqual(len(f0.bytes), 0)
def test_byte_place_single_field(self): b = Byte() # place a field with lsb = 0 (=> msb = 3) f0 = Field("f0", 4) self.assertTrue(b.place(f0, 3)) self.assertEqual(len(b.fields), 1) self.assertEqual(b.fields[0], f0) # field remains unaffected self.assertEqual(f0.msb, -1) self.assertEqual(f0.lsb, -1) self.assertEqual(f0.size, 4) self.assertEqual(len(f0.bytes), 0)
def __init__(self, to, to_field=None, rel_class=OneOnOneRelation, **kwargs): try: to_name = to._meta.object_name.lower() except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT if is_accepted_type_one_of(to): contains_built_in_type = True else: assert isinstance(to, basestring), "%s(%r) is invalid. First parameter to related object must be either a model, a model name, or the string %r" % (self.__class__.__name__, to, RECURSIVE_RELATIONSHIP_CONSTANT) else: #assert not to._meta.abstract, "%s cannot define a relation with abstract class %s" % (self.__class__.__name__, to._meta.object_name) # For backwards compatibility purposes, we need to *try* and set # the to_field during FK construction. It won't be guaranteed to # be correct until contribute_to_class is called. Refs #12190. to_field = to_field kwargs['verbose_name'] = kwargs.get('verbose_name', None) kwargs['rel'] = rel_class(self,to, to_field, related_name=kwargs.pop('related_name', None), limit_choices_to=kwargs.pop('limit_choices_to', None), lookup_overrides=kwargs.pop('lookup_overrides', None), parent_link=kwargs.pop('parent_link', False)) Field.__init__(self, **kwargs)
def test_field_invalid_place(self): # try to place Field in single byte, in invalid position b1 = Byte() self.assertFalse(Field("too_long", 12).place(b1, 7)) self.assertFalse(Field("overlap_msb", 4).place(b1, 10)) self.assertFalse(Field("overlap_lsb", 12).place(b1, 2)) f = Field("test", 4) self.assertTrue(f.place(b1, 3)) # field cannot be placed twice, no matter, what the byte looks like b2 = Byte() self.assertFalse(f.place(b2, 3))
def resolve_fields(fields_node, read_only=False): fields = [] known_types = [ast.Tuple, ast.List, ast.Set] if isinstance(fields_node, ast.BinOp): assert isinstance(fields_node.op, ast.Add) # if either is Attribute, resolve_fields returns [] which is fine # since it will be handled by the logic in bases return resolve_fields(fields_node.left) + resolve_fields( fields_node.right) if any(isinstance(fields_node, t) for t in known_types): for field_node in fields_node.elts: field = Field(field_name=Resolver.resolve(field_node), read_only=read_only) fields.append(field) return fields
def test_unmarshal(self): b0 = Byte(0) b1 = Byte(1) f0 = Field("test", 4) f1 = Field("test2", 8) self.assertTrue(f0.place(b1, 3)) # for unmarshalling we need the field, not the byte self.assertRaises(AssertionError, self.cg.unmarshal, b1) self.assertEqual(self.cg.unmarshal(f0), "pre->test = ((data[ 1] >> 0) & 0x0f) << 0;") self.assertTrue(f1.place([b0, b1], 11)) self.assertEqual( self.cg.unmarshal(f1), "pre->test2 = ((data[ 0] >> 0) & 0x0f) << 4 | ((data[ 1] >> 4) & 0x0f) << 0;" )
def test_inverse(self): a = Field(7, 23) self.assertEqual(a.inverse().value, 10) self.assertEqual((a.inverse() * 7).value, 1)
def validate(self, value): return Field.validate(self, value)
def parse_field(name): if isinstance(name, Field) or isinstance(name, FieldSize): size = name else: size = Field.find(name) return size
def test_field_place_multiple_bytes(self): # place long field in two bytes bytes = [Byte(), Byte()] f = Field("too_long_for_one_byte", 12) self.assertTrue(f.place(bytes, 14)) self.assertEqual(len(f.bytes), 2) self.assertEqual(f.bytes[0], bytes[0]) self.assertEqual(f.bytes[1], bytes[1]) # msb and lsb are always relative to the underlying byte list self.assertEqual(f.msb, 14) self.assertEqual(f.lsb, 3) # check that bytes know the fields self.assertEqual(len(bytes[0].fields), 1) self.assertEqual(len(bytes[1].fields), 1) self.assertEqual(bytes[0].fields[0], f) self.assertEqual(bytes[1].fields[0], f) # check relative positions # in bytes[0]: 0FFFFFFF self.assertEqual(f.msb_in_byte(bytes[0]), 6) self.assertEqual(f.lsb_in_byte(bytes[0]), 0) self.assertEqual(f.size_in_byte(bytes[0]), 7) # in bytes[1]: FFFFF000 self.assertEqual(f.msb_in_byte(bytes[1]), 7) self.assertEqual(f.lsb_in_byte(bytes[1]), 3) self.assertEqual(f.size_in_byte(bytes[1]), 5) # place one field in more bytes than needed bytes2 = [Byte(), Byte(), Byte()] f2 = Field("too_long_for_one_byte", 12) self.assertTrue(f2.place(bytes2, 23)) self.assertEqual(len(f2.bytes), 2) self.assertEqual(f2.bytes[0], bytes2[0]) self.assertEqual(f2.bytes[1], bytes2[1]) bytes3 = [Byte(), Byte(), Byte()] f3 = Field("too_long_for_one_byte", 12) self.assertTrue(f3.place(bytes3, 14)) self.assertEqual(len(f3.bytes), 2) self.assertEqual(f3.bytes[0], bytes3[1]) self.assertEqual(f3.bytes[1], bytes3[2])
def test_byte_boundary_sort_placement(self): pp = ByteBoundarySortPlacement() f0 = Field("a", 4) f1 = Field("c", 7) f2 = Field("b0", 1) f3 = Field("d", 5) f4 = Field("e", 3) f5 = Field("big", 32) f6 = Field("b3", 1) fields = [f0, f1, f2, f3, f4, f5, f6] front_field = Field("first_id", 5) bytes = pp.place(fields, front_field=front_field) self.assertEqual(len(bytes), 7) self.assertEqual(front_field.msb_in_byte(bytes[0]), 7) self.assertEqual(front_field.lsb_in_byte(bytes[0]), 3) self.assertEqual(f4.msb_in_byte(bytes[0]), 2) self.assertEqual(f4.lsb_in_byte(bytes[0]), 0) # 32bit data self.assertEqual(f5.msb_in_byte(bytes[1]), 7) self.assertEqual(f5.lsb_in_byte(bytes[1]), 0) self.assertEqual(f5.msb_in_byte(bytes[2]), 7) self.assertEqual(f5.lsb_in_byte(bytes[2]), 0) self.assertEqual(f5.msb_in_byte(bytes[3]), 7) self.assertEqual(f5.lsb_in_byte(bytes[3]), 0) self.assertEqual(f5.msb_in_byte(bytes[4]), 7) self.assertEqual(f5.lsb_in_byte(bytes[4]), 0) # self.assertEqual(f2.msb_in_byte(bytes[5]), 7) self.assertEqual(f2.lsb_in_byte(bytes[5]), 7) self.assertEqual(f1.msb_in_byte(bytes[5]), 6) self.assertEqual(f1.lsb_in_byte(bytes[5]), 0) self.assertEqual(f6.msb_in_byte(bytes[6]), 5) self.assertEqual(f6.lsb_in_byte(bytes[6]), 5) self.assertEqual(f3.msb_in_byte(bytes[6]), 4) self.assertEqual(f3.lsb_in_byte(bytes[6]), 0) self.assertEqual(f0.msb_in_byte(bytes[7]), 3) self.assertEqual(f0.lsb_in_byte(bytes[7]), 0)