:rtype: :class:`~kitty.model.low_level.calculated.Size`
    :return: Size field, which holds the size in bytes of the sized field
357041
def SizeInBytes(sized_field, length, encoder=ENC_INT_DEFAULT, fuzzable=False, name=None):
    '''
    
    '''
    return Size(sized_field=sized_field, length=length, calc_func=lambda x: len(x) // 8, encoder=encoder, fuzzable=fuzzable, name=name)
204427
def calculate_size(name, sequence):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += LONG_SIZE_IN_BYTES
    return data_size
967729
def calculate_size(name, attribute, ordered):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_str(attribute)
    data_size += BOOLEAN_SIZE_IN_BYTES
    return data_size
1136973
def size(self):
    
    if self._size is None:
      self._size = 0
      for csv_file in self.files:
        self._size += sum(1 if line else 0 for line in _util.open_local_or_gcs(csv_file, 'r'))

    return self._size
706024
def calculate_size(name, timeout_millis):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += LONG_SIZE_IN_BYTES
    return data_size
1250044
def size(self):
        
        if hasattr(self._stream, 'len'):
            return len(self._stream)
        elif hasattr(self._stream, 'fileno'):
            return os.fstat(self._stream.fileno()).st_size
        else:
            cur_pos = self._stream.tell()
            size = self._stream.seek(0, os.SEEK_END)
            self._stream.seek(cur_pos)
            return size
793841
def Size(self):
        
        scriptsize = 0
        if self.Script is not None:
            scriptsize = self.Script.Size()
        return s.uint32 + s.uint256 + s.uint256 + s.uint32 + s.uint32 + s.uint64 + s.uint160 + 1 + scriptsize
1278465
def filesize(self):
        
        if self.from_stdin:
            return None
        if not self._filesize:
            self._calculate_bounds()
        return self._filesize
987358
def Size(self):
        
        s = super(Block, self).Size() + GetVarSize(self.Transactions)
        return s
302307
def size(self):
        
        size = self._backend._vispy_get_size()
        return (size[0] // self._px_scale, size[1] // self._px_scale)
563651
def get_size(self, value=None):
        
        if isinstance(value, type(self)):
            return value.get_size()

        return 2 + self.length
817540
def calculate_size(name, index):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += INT_SIZE_IN_BYTES
    return data_size
1137289
def calculate_size(name, function):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_data(function)
    return data_size
1226113
def size(self):
        

        if self is NULL:
            return 0
        return 1 + self.left.size() + self.right.size()
272006
def calculate_size(name, expected, updated):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += BOOLEAN_SIZE_IN_BYTES
    if expected is not None:
        data_size += calculate_size_data(expected)
    data_size += BOOLEAN_SIZE_IN_BYTES
    if updated is not None:
        data_size += calculate_size_data(updated)
    return data_size
445514
def size(self, size=None):
        """"""

        if size is None:
            return self._size
        else:
            if not is_numeric(size):
                raise TypeError(
                 "size must be number, not '%s'" % str(size)
                )
            self._size = size
529059
def calculate_size(name, batch_size):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += INT_SIZE_IN_BYTES
    return data_size