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
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 __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 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 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)
