Return allocated size (fraction of total snapshot volume space). If this is not a snapshot volume,
		than RuntimeError exception is raised.

		:return: float
481881
def snapshot_allocation(self):
		
		check_cmd = ['lvs', self.volume_path(), '-o', 'snap_percent', '--noheadings']
		output = subprocess.check_output(check_cmd, timeout=self.__class__.__lvm_snapshot_check_cmd_timeout__)
		output = output.decode().strip()
		if len(output) == 0:
			raise RuntimeError('Unable to check general logical volume')
		return float(output.replace(',', '.', 1))
1271271
def itemsize(self):
        
        return self._items[:self._count, 1] - self._items[:self._count, 0]
101519
def file_size(self):
        
        stream = self.get_file_stream()
        stream.seek(0, os.SEEK_END)
        return stream.tell()
1141637
async def container_size(
            self, container_len=None, container_type=None, params=None
    ):
        
        if hasattr(container_type, "serialize_archive"):
            raise ValueError("not supported")

        if self.writing:
            return await self._dump_container_size(
                self.iobj, container_len, container_type, params
            )
        else:
            raise ValueError("Not supported")
946128
def __get_data_size(self):
        
        response = self.__response
        if response == const.CMD_PREPARE_DATA:
            size = unpack('I', self.__data[:4])[0]
            return size
        else:
            return 0
1207752
def size(self):
        

        size = 0
        try:
            tip = self.get_changeset()
            for topnode, dirs, files in tip.walk('/'):
                for f in files:
                    size += tip.get_file_size(f.path)
                for dir in dirs:
                    for f in files:
                        size += tip.get_file_size(f.path)

        except RepositoryError:
            pass
        return size
429729
def data_size(metadata):
    
    info = metadata['info']

    if 'length' in info:
        # Single file
        total_size = info['length']
    else:
        # Directory structure
        total_size = sum([f['length'] for f in info['files']])

    return total_size
524486
def size(self, type=None, failed=False):
        
        return len(self.nodes(type=type, failed=failed))
837846
def calculate_size(timeout, durability, transaction_type, thread_id):
    
    data_size = 0
    data_size += LONG_SIZE_IN_BYTES
    data_size += INT_SIZE_IN_BYTES
    data_size += INT_SIZE_IN_BYTES
    data_size += LONG_SIZE_IN_BYTES
    return data_size
945862
def _current_size(self):
        
        deletes, adds, _ = Watch._extract_changes(self.doc_map, self.change_map, None)
        return len(self.doc_map) + len(adds) - len(deletes)
961683
def get_file_size(filename):
    
    if filename is None:
        return float(0)
    if type(filename) is list:
        return float(sum([get_file_size(x) for x in filename]))
    try:
        total_bytes = sum([float(os.stat(f).st_size)
                           for f in filename.split(" ") if f is not ''])
    except OSError:
        # File not found
        return 0.0
    else:
        return float(total_bytes) / (1024 ** 3)
36461
def calculate_size(name, thread_id):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += LONG_SIZE_IN_BYTES
    return data_size
235714
def calculate_size(name, key, thread_id):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += calculate_size_data(key)
    data_size += LONG_SIZE_IN_BYTES
    return data_size
460366
def filesize(fileobj):
    
    current = fileobj.tell()
    fileobj.seek(0, 2)
    end = fileobj.tell()
    fileobj.seek(current)
    return end
848066
def size(self):
        
        result = self.grouper.size()

        if isinstance(self.obj, Series):
            result.name = getattr(self.obj, 'name', None)
        return result
1269109
def size(self):
        
        return self._size_full_intension \
                    - len(self.exclude)\
                    + len(self.include)
1314568
def volume(self):
        
        sizes = self.compute_cell_sizes(length=False, area=False, volume=True)
        return np.sum(sizes.cell_arrays['Volume'])