cengal.data_containers.fast_fifo.versions.v_1.fast_fifo
1#!/usr/bin/env python 2# coding=utf-8 3 4# Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space> 5# 6# Licensed under the Apache License, Version 2.0 (the "License"); 7# you may not use this file except in compliance with the License. 8# You may obtain a copy of the License at 9# 10# http://www.apache.org/licenses/LICENSE-2.0 11# 12# Unless required by applicable law or agreed to in writing, software 13# distributed under the License is distributed on an "AS IS" BASIS, 14# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15# See the License for the specific language governing permissions and 16# limitations under the License. 17 18from collections import deque 19 20from cengal.code_flow_control.smart_values import ValueCache, ValueExistence 21from cengal.code_inspection.line_profiling import set_profiler 22 23""" 24Быстрый модуль FIFO. Скорость достигается за счет уменьшенного количества аллокаций и деаллокаций памяти и 25соответственно, за счет бОльшего размера используемой памяти в пИке. Расход памяти неравномерный: сначала происходит 26постоянное увеличение размера используемой памяти, а при превышении лимита - вся ненужная память деалоцируется 27одномоментно, что приводит лишь к одному пересозданию контейнерного списка блоков. 28""" 29 30__author__ = "ButenkoMS <gtalk@butenkoms.space>" 31__copyright__ = "Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>" 32__credits__ = ["ButenkoMS <gtalk@butenkoms.space>", ] 33__license__ = "Apache License, Version 2.0" 34__version__ = "4.4.1" 35__maintainer__ = "ButenkoMS <gtalk@butenkoms.space>" 36__email__ = "gtalk@butenkoms.space" 37# __status__ = "Prototype" 38__status__ = "Development" 39# __status__ = "Production" 40 41 42# set_profiler(True) 43set_profiler(False) 44 45 46class FIFOIsEmpty(Exception): 47 pass 48 49 50class FIFO: 51 def __init__(self, on_hold_limit=None): 52 self._init_param__on_hold_limit = on_hold_limit 53 54 self._l = list() 55 self._offset = 0 56 self._offset_limit = on_hold_limit or 1000 57 self._useful_size = 0 58 self._real_size = 0 59 60 def put(self, data): 61 self._l.append(data) 62 self._useful_size += 1 63 self._real_size += 1 64 65 def extend(self, iterable_data): 66 self._l.extend(iterable_data) 67 new_full_length = len(self._l) 68 diff = new_full_length - self._real_size 69 self._useful_size += diff 70 self._real_size += diff 71 72 def get(self): 73 # l_offset_limit = 1000: 574305.7210067833 iterations per second 74 # PyPy: l_offset_limit = 1000: 6666620.042915044 iterations per second 75 if self._useful_size <= 0: 76 raise FIFOIsEmpty() 77 78 result = self._l[self._offset] 79 self._useful_size -= 1 80 self._offset += 1 81 if self._offset >= self._offset_limit: 82 self._real_size -= self._offset 83 self._l = self._l[self._offset:] 84 self._offset = 0 85 return result 86 87 def _free(self, num): 88 self._useful_size -= num 89 self._offset += num 90 if self._offset >= self._offset_limit: 91 self._real_size -= self._offset 92 self._l = self._l[self._offset:] 93 self._offset = 0 94 95 def size(self): 96 return self._useful_size 97 98 def full_size(self): 99 return self._real_size 100 101 def remove(self): 102 pass 103 104 def __copy__(self): 105 return FIFO(self._init_param__on_hold_limit) 106 107 108class FIFOWithLengthControl(FIFO): 109 def __init__(self, on_hold_limit=None, on_hold_data_size_limit=None, 110 external_data_full_size: ValueExistence = None, 111 external_deletable_data_full_size: ValueExistence = None): 112 super(FIFOWithLengthControl, self).__init__(on_hold_limit) 113 self._removed = False 114 115 self._init_param__on_hold_data_size_limit = on_hold_data_size_limit 116 self._init_param__external_data_full_size = external_data_full_size 117 self._init_param__external_deletable_data_full_size = external_deletable_data_full_size 118 119 self._l_length = list() 120 # self._l_deletable_length = list() 121 self._data_full_size = ValueCache() 122 self._data_full_size.set(0) 123 self._deletable_data_full_size = 0 124 self._on_hold_data_size_limit = on_hold_data_size_limit or 1024**2 * 10 125 self._external_data_full_size = external_data_full_size or ValueExistence(False, 0) 126 self._external_deletable_data_full_size = external_deletable_data_full_size or ValueExistence(False, 0) 127 128 def put(self, data): 129 if not self._data_full_size: 130 self._calculate_data_full_size() 131 132 super(FIFOWithLengthControl, self).put(data) 133 134 data_size = len(data) 135 self._l_length.append(data_size) 136 self._data_full_size.value += data_size 137 self._external_data_full_size.value += data_size 138 139 def extend(self, iterable_data): 140 if not self._data_full_size: 141 self._calculate_data_full_size() 142 143 index = self._real_size 144 145 self._l.extend(iterable_data) 146 new_full_length = len(self._l) 147 diff = new_full_length - self._real_size 148 self._useful_size += diff 149 self._real_size += diff 150 full_size_diff = 0 151 152 while index < self._real_size: 153 piece_size = len(self._l[index]) 154 self._l_length.append(piece_size) 155 full_size_diff += piece_size 156 index += 1 157 self._data_full_size.value += full_size_diff 158 self._external_data_full_size.value += full_size_diff 159 160 def get(self): 161 # l_offset_limit = 1000: 574305.7210067833 iterations per second 162 # PyPy: l_offset_limit = 1000: 6666620.042915044 iterations per second 163 if self._useful_size <= 0: 164 raise FIFOIsEmpty() 165 166 if not self._data_full_size: 167 self._calculate_data_full_size() 168 169 result = self._l[self._offset] 170 result_len = self._l_length[self._offset] 171 # self._l_deletable_length.append(result_len) 172 self._deletable_data_full_size += result_len 173 self._external_deletable_data_full_size.value += result_len 174 175 self._useful_size -= 1 176 self._offset += 1 177 if (self._offset >= self._offset_limit) or (self._deletable_data_full_size > self._on_hold_data_size_limit): 178 self._real_size -= self._offset 179 self._l = self._l[self._offset:] 180 # diff_full_data_size = sum(self._l_length[:self._offset]) 181 # diff_full_data_size = self._deletable_data_full_size 182 self._data_full_size.value -= self._deletable_data_full_size 183 self._external_data_full_size.value -= self._deletable_data_full_size 184 self._l_length = self._l_length[self._offset:] 185 self._offset = 0 186 # self.get_data_full_size() 187 # self._l_deletable_length = list() 188 self._external_deletable_data_full_size.value -= self._deletable_data_full_size 189 self._deletable_data_full_size = 0 190 return result 191 192 # @profile 193 def _free(self, num): 194 result = self._l_length[self._offset:self._offset + num] 195 result_len = sum(result) 196 # self._l_deletable_length.extend(result) 197 self._deletable_data_full_size += result_len 198 self._external_deletable_data_full_size.value += result_len 199 200 self._useful_size -= num 201 self._offset += num 202 if (self._offset >= self._offset_limit) or (self._deletable_data_full_size > self._on_hold_data_size_limit): 203 self._real_size -= self._offset 204 self._l = self._l[self._offset:] 205 self._data_full_size.value -= self._deletable_data_full_size 206 self._external_data_full_size.value -= self._deletable_data_full_size 207 self._l_length = self._l_length[self._offset:] 208 self._offset = 0 209 # self._l_deletable_length = list() 210 self._external_deletable_data_full_size.value -= self._deletable_data_full_size 211 self._deletable_data_full_size = 0 212 213 def _calculate_data_full_size(self): 214 data_full_size = sum(self._l_length) 215 last_data_full_size = self._data_full_size.value 216 diff_data_full_size = data_full_size - last_data_full_size 217 self._data_full_size.set(data_full_size) 218 self._external_data_full_size.value += diff_data_full_size 219 220 def get_data_full_size(self): 221 if not self._data_full_size: 222 self._calculate_data_full_size() 223 224 return self._data_full_size.value 225 226 def get_deletable_data_full_size(self): 227 return self._deletable_data_full_size 228 229 def remove(self): 230 if not self._removed: 231 self._external_data_full_size.value -= self._data_full_size.value 232 self._external_deletable_data_full_size.value -= self._deletable_data_full_size 233 self._removed = True 234 235 def __copy__(self): 236 return FIFOWithLengthControl(self._init_param__on_hold_limit, 237 self._init_param__on_hold_data_size_limit, 238 self._init_param__external_data_full_size, 239 self._init_param__external_deletable_data_full_size) 240 241 def __del__(self): 242 self.remove() 243 244 245class FIFODequeWithLengthControl: 246 def __init__(self, external_data_full_size: ValueExistence = None): 247 self._removed = False 248 249 self._l = deque() 250 self._real_size = 0 251 252 self._init_param__external_data_full_size = external_data_full_size 253 254 # self._l_length = deque() 255 self._data_full_size = 0 256 self._external_data_full_size = external_data_full_size or ValueExistence(False, 0) 257 258 def put(self, data): 259 self._l.append(data) 260 self._real_size += 1 261 262 data_size = len(data) 263 # self._l_length.append(data_size) 264 self._data_full_size += data_size 265 self._external_data_full_size.value += data_size 266 267 def extend(self, iterable_data): 268 full_size_diff = 0 269 for elem in iterable_data: 270 self._l.append(elem) 271 self._real_size += 1 272 elem_size = len(elem) 273 # self._l_length.append(elem_size) 274 full_size_diff += elem_size 275 self._data_full_size += full_size_diff 276 self._external_data_full_size.value += full_size_diff 277 278 def get(self): 279 if self._real_size <= 0: 280 raise FIFOIsEmpty() 281 282 result = self._l.popleft() 283 # result_len = self._l_length.popleft() 284 result_len = len(result) 285 self._real_size -= 1 286 self._data_full_size -= result_len 287 self._external_data_full_size.value -= result_len 288 289 return result 290 291 def get_at_least_size(self, minimum_data_size): 292 if self._real_size <= 0: 293 raise FIFOIsEmpty() 294 295 result_data = deque() 296 result_size = 0 297 result_qnt = 0 298 299 while self._real_size and (result_size < minimum_data_size): 300 another_piece = self._l.popleft() 301 result_data.append(another_piece) 302 self._real_size -= 1 303 # result_len = self._l_length.popleft() 304 result_len = len(another_piece) 305 self._data_full_size -= result_len 306 self._external_data_full_size.value -= result_len 307 result_size += result_len 308 result_qnt += 1 309 310 result = (result_data, result_size, result_qnt) 311 return result 312 313 def get_data_full_size(self): 314 return self._data_full_size 315 316 def remove(self): 317 if not self._removed: 318 self._external_data_full_size.value -= self._data_full_size 319 self._removed = True 320 321 def __copy__(self): 322 return FIFODequeWithLengthControl(self._init_param__external_data_full_size) 323 324 def __del__(self): 325 self.remove() 326 327 def size(self): 328 return self._real_size 329 330 def full_size(self): 331 return self._real_size
class
FIFOIsEmpty(builtins.Exception):
Common base class for all non-exit exceptions.
Inherited Members
- builtins.Exception
- Exception
- builtins.BaseException
- with_traceback
- args
class
FIFO:
51class FIFO: 52 def __init__(self, on_hold_limit=None): 53 self._init_param__on_hold_limit = on_hold_limit 54 55 self._l = list() 56 self._offset = 0 57 self._offset_limit = on_hold_limit or 1000 58 self._useful_size = 0 59 self._real_size = 0 60 61 def put(self, data): 62 self._l.append(data) 63 self._useful_size += 1 64 self._real_size += 1 65 66 def extend(self, iterable_data): 67 self._l.extend(iterable_data) 68 new_full_length = len(self._l) 69 diff = new_full_length - self._real_size 70 self._useful_size += diff 71 self._real_size += diff 72 73 def get(self): 74 # l_offset_limit = 1000: 574305.7210067833 iterations per second 75 # PyPy: l_offset_limit = 1000: 6666620.042915044 iterations per second 76 if self._useful_size <= 0: 77 raise FIFOIsEmpty() 78 79 result = self._l[self._offset] 80 self._useful_size -= 1 81 self._offset += 1 82 if self._offset >= self._offset_limit: 83 self._real_size -= self._offset 84 self._l = self._l[self._offset:] 85 self._offset = 0 86 return result 87 88 def _free(self, num): 89 self._useful_size -= num 90 self._offset += num 91 if self._offset >= self._offset_limit: 92 self._real_size -= self._offset 93 self._l = self._l[self._offset:] 94 self._offset = 0 95 96 def size(self): 97 return self._useful_size 98 99 def full_size(self): 100 return self._real_size 101 102 def remove(self): 103 pass 104 105 def __copy__(self): 106 return FIFO(self._init_param__on_hold_limit)
def
get(self):
73 def get(self): 74 # l_offset_limit = 1000: 574305.7210067833 iterations per second 75 # PyPy: l_offset_limit = 1000: 6666620.042915044 iterations per second 76 if self._useful_size <= 0: 77 raise FIFOIsEmpty() 78 79 result = self._l[self._offset] 80 self._useful_size -= 1 81 self._offset += 1 82 if self._offset >= self._offset_limit: 83 self._real_size -= self._offset 84 self._l = self._l[self._offset:] 85 self._offset = 0 86 return result
109class FIFOWithLengthControl(FIFO): 110 def __init__(self, on_hold_limit=None, on_hold_data_size_limit=None, 111 external_data_full_size: ValueExistence = None, 112 external_deletable_data_full_size: ValueExistence = None): 113 super(FIFOWithLengthControl, self).__init__(on_hold_limit) 114 self._removed = False 115 116 self._init_param__on_hold_data_size_limit = on_hold_data_size_limit 117 self._init_param__external_data_full_size = external_data_full_size 118 self._init_param__external_deletable_data_full_size = external_deletable_data_full_size 119 120 self._l_length = list() 121 # self._l_deletable_length = list() 122 self._data_full_size = ValueCache() 123 self._data_full_size.set(0) 124 self._deletable_data_full_size = 0 125 self._on_hold_data_size_limit = on_hold_data_size_limit or 1024**2 * 10 126 self._external_data_full_size = external_data_full_size or ValueExistence(False, 0) 127 self._external_deletable_data_full_size = external_deletable_data_full_size or ValueExistence(False, 0) 128 129 def put(self, data): 130 if not self._data_full_size: 131 self._calculate_data_full_size() 132 133 super(FIFOWithLengthControl, self).put(data) 134 135 data_size = len(data) 136 self._l_length.append(data_size) 137 self._data_full_size.value += data_size 138 self._external_data_full_size.value += data_size 139 140 def extend(self, iterable_data): 141 if not self._data_full_size: 142 self._calculate_data_full_size() 143 144 index = self._real_size 145 146 self._l.extend(iterable_data) 147 new_full_length = len(self._l) 148 diff = new_full_length - self._real_size 149 self._useful_size += diff 150 self._real_size += diff 151 full_size_diff = 0 152 153 while index < self._real_size: 154 piece_size = len(self._l[index]) 155 self._l_length.append(piece_size) 156 full_size_diff += piece_size 157 index += 1 158 self._data_full_size.value += full_size_diff 159 self._external_data_full_size.value += full_size_diff 160 161 def get(self): 162 # l_offset_limit = 1000: 574305.7210067833 iterations per second 163 # PyPy: l_offset_limit = 1000: 6666620.042915044 iterations per second 164 if self._useful_size <= 0: 165 raise FIFOIsEmpty() 166 167 if not self._data_full_size: 168 self._calculate_data_full_size() 169 170 result = self._l[self._offset] 171 result_len = self._l_length[self._offset] 172 # self._l_deletable_length.append(result_len) 173 self._deletable_data_full_size += result_len 174 self._external_deletable_data_full_size.value += result_len 175 176 self._useful_size -= 1 177 self._offset += 1 178 if (self._offset >= self._offset_limit) or (self._deletable_data_full_size > self._on_hold_data_size_limit): 179 self._real_size -= self._offset 180 self._l = self._l[self._offset:] 181 # diff_full_data_size = sum(self._l_length[:self._offset]) 182 # diff_full_data_size = self._deletable_data_full_size 183 self._data_full_size.value -= self._deletable_data_full_size 184 self._external_data_full_size.value -= self._deletable_data_full_size 185 self._l_length = self._l_length[self._offset:] 186 self._offset = 0 187 # self.get_data_full_size() 188 # self._l_deletable_length = list() 189 self._external_deletable_data_full_size.value -= self._deletable_data_full_size 190 self._deletable_data_full_size = 0 191 return result 192 193 # @profile 194 def _free(self, num): 195 result = self._l_length[self._offset:self._offset + num] 196 result_len = sum(result) 197 # self._l_deletable_length.extend(result) 198 self._deletable_data_full_size += result_len 199 self._external_deletable_data_full_size.value += result_len 200 201 self._useful_size -= num 202 self._offset += num 203 if (self._offset >= self._offset_limit) or (self._deletable_data_full_size > self._on_hold_data_size_limit): 204 self._real_size -= self._offset 205 self._l = self._l[self._offset:] 206 self._data_full_size.value -= self._deletable_data_full_size 207 self._external_data_full_size.value -= self._deletable_data_full_size 208 self._l_length = self._l_length[self._offset:] 209 self._offset = 0 210 # self._l_deletable_length = list() 211 self._external_deletable_data_full_size.value -= self._deletable_data_full_size 212 self._deletable_data_full_size = 0 213 214 def _calculate_data_full_size(self): 215 data_full_size = sum(self._l_length) 216 last_data_full_size = self._data_full_size.value 217 diff_data_full_size = data_full_size - last_data_full_size 218 self._data_full_size.set(data_full_size) 219 self._external_data_full_size.value += diff_data_full_size 220 221 def get_data_full_size(self): 222 if not self._data_full_size: 223 self._calculate_data_full_size() 224 225 return self._data_full_size.value 226 227 def get_deletable_data_full_size(self): 228 return self._deletable_data_full_size 229 230 def remove(self): 231 if not self._removed: 232 self._external_data_full_size.value -= self._data_full_size.value 233 self._external_deletable_data_full_size.value -= self._deletable_data_full_size 234 self._removed = True 235 236 def __copy__(self): 237 return FIFOWithLengthControl(self._init_param__on_hold_limit, 238 self._init_param__on_hold_data_size_limit, 239 self._init_param__external_data_full_size, 240 self._init_param__external_deletable_data_full_size) 241 242 def __del__(self): 243 self.remove()
FIFOWithLengthControl( on_hold_limit=None, on_hold_data_size_limit=None, external_data_full_size: cengal.code_flow_control.smart_values.versions.v_2.smart_values.ValueExistence = None, external_deletable_data_full_size: cengal.code_flow_control.smart_values.versions.v_2.smart_values.ValueExistence = None)
110 def __init__(self, on_hold_limit=None, on_hold_data_size_limit=None, 111 external_data_full_size: ValueExistence = None, 112 external_deletable_data_full_size: ValueExistence = None): 113 super(FIFOWithLengthControl, self).__init__(on_hold_limit) 114 self._removed = False 115 116 self._init_param__on_hold_data_size_limit = on_hold_data_size_limit 117 self._init_param__external_data_full_size = external_data_full_size 118 self._init_param__external_deletable_data_full_size = external_deletable_data_full_size 119 120 self._l_length = list() 121 # self._l_deletable_length = list() 122 self._data_full_size = ValueCache() 123 self._data_full_size.set(0) 124 self._deletable_data_full_size = 0 125 self._on_hold_data_size_limit = on_hold_data_size_limit or 1024**2 * 10 126 self._external_data_full_size = external_data_full_size or ValueExistence(False, 0) 127 self._external_deletable_data_full_size = external_deletable_data_full_size or ValueExistence(False, 0)
def
put(self, data):
129 def put(self, data): 130 if not self._data_full_size: 131 self._calculate_data_full_size() 132 133 super(FIFOWithLengthControl, self).put(data) 134 135 data_size = len(data) 136 self._l_length.append(data_size) 137 self._data_full_size.value += data_size 138 self._external_data_full_size.value += data_size
def
extend(self, iterable_data):
140 def extend(self, iterable_data): 141 if not self._data_full_size: 142 self._calculate_data_full_size() 143 144 index = self._real_size 145 146 self._l.extend(iterable_data) 147 new_full_length = len(self._l) 148 diff = new_full_length - self._real_size 149 self._useful_size += diff 150 self._real_size += diff 151 full_size_diff = 0 152 153 while index < self._real_size: 154 piece_size = len(self._l[index]) 155 self._l_length.append(piece_size) 156 full_size_diff += piece_size 157 index += 1 158 self._data_full_size.value += full_size_diff 159 self._external_data_full_size.value += full_size_diff
def
get(self):
161 def get(self): 162 # l_offset_limit = 1000: 574305.7210067833 iterations per second 163 # PyPy: l_offset_limit = 1000: 6666620.042915044 iterations per second 164 if self._useful_size <= 0: 165 raise FIFOIsEmpty() 166 167 if not self._data_full_size: 168 self._calculate_data_full_size() 169 170 result = self._l[self._offset] 171 result_len = self._l_length[self._offset] 172 # self._l_deletable_length.append(result_len) 173 self._deletable_data_full_size += result_len 174 self._external_deletable_data_full_size.value += result_len 175 176 self._useful_size -= 1 177 self._offset += 1 178 if (self._offset >= self._offset_limit) or (self._deletable_data_full_size > self._on_hold_data_size_limit): 179 self._real_size -= self._offset 180 self._l = self._l[self._offset:] 181 # diff_full_data_size = sum(self._l_length[:self._offset]) 182 # diff_full_data_size = self._deletable_data_full_size 183 self._data_full_size.value -= self._deletable_data_full_size 184 self._external_data_full_size.value -= self._deletable_data_full_size 185 self._l_length = self._l_length[self._offset:] 186 self._offset = 0 187 # self.get_data_full_size() 188 # self._l_deletable_length = list() 189 self._external_deletable_data_full_size.value -= self._deletable_data_full_size 190 self._deletable_data_full_size = 0 191 return result
class
FIFODequeWithLengthControl:
246class FIFODequeWithLengthControl: 247 def __init__(self, external_data_full_size: ValueExistence = None): 248 self._removed = False 249 250 self._l = deque() 251 self._real_size = 0 252 253 self._init_param__external_data_full_size = external_data_full_size 254 255 # self._l_length = deque() 256 self._data_full_size = 0 257 self._external_data_full_size = external_data_full_size or ValueExistence(False, 0) 258 259 def put(self, data): 260 self._l.append(data) 261 self._real_size += 1 262 263 data_size = len(data) 264 # self._l_length.append(data_size) 265 self._data_full_size += data_size 266 self._external_data_full_size.value += data_size 267 268 def extend(self, iterable_data): 269 full_size_diff = 0 270 for elem in iterable_data: 271 self._l.append(elem) 272 self._real_size += 1 273 elem_size = len(elem) 274 # self._l_length.append(elem_size) 275 full_size_diff += elem_size 276 self._data_full_size += full_size_diff 277 self._external_data_full_size.value += full_size_diff 278 279 def get(self): 280 if self._real_size <= 0: 281 raise FIFOIsEmpty() 282 283 result = self._l.popleft() 284 # result_len = self._l_length.popleft() 285 result_len = len(result) 286 self._real_size -= 1 287 self._data_full_size -= result_len 288 self._external_data_full_size.value -= result_len 289 290 return result 291 292 def get_at_least_size(self, minimum_data_size): 293 if self._real_size <= 0: 294 raise FIFOIsEmpty() 295 296 result_data = deque() 297 result_size = 0 298 result_qnt = 0 299 300 while self._real_size and (result_size < minimum_data_size): 301 another_piece = self._l.popleft() 302 result_data.append(another_piece) 303 self._real_size -= 1 304 # result_len = self._l_length.popleft() 305 result_len = len(another_piece) 306 self._data_full_size -= result_len 307 self._external_data_full_size.value -= result_len 308 result_size += result_len 309 result_qnt += 1 310 311 result = (result_data, result_size, result_qnt) 312 return result 313 314 def get_data_full_size(self): 315 return self._data_full_size 316 317 def remove(self): 318 if not self._removed: 319 self._external_data_full_size.value -= self._data_full_size 320 self._removed = True 321 322 def __copy__(self): 323 return FIFODequeWithLengthControl(self._init_param__external_data_full_size) 324 325 def __del__(self): 326 self.remove() 327 328 def size(self): 329 return self._real_size 330 331 def full_size(self): 332 return self._real_size
FIFODequeWithLengthControl( external_data_full_size: cengal.code_flow_control.smart_values.versions.v_2.smart_values.ValueExistence = None)
247 def __init__(self, external_data_full_size: ValueExistence = None): 248 self._removed = False 249 250 self._l = deque() 251 self._real_size = 0 252 253 self._init_param__external_data_full_size = external_data_full_size 254 255 # self._l_length = deque() 256 self._data_full_size = 0 257 self._external_data_full_size = external_data_full_size or ValueExistence(False, 0)
def
extend(self, iterable_data):
268 def extend(self, iterable_data): 269 full_size_diff = 0 270 for elem in iterable_data: 271 self._l.append(elem) 272 self._real_size += 1 273 elem_size = len(elem) 274 # self._l_length.append(elem_size) 275 full_size_diff += elem_size 276 self._data_full_size += full_size_diff 277 self._external_data_full_size.value += full_size_diff
def
get(self):
279 def get(self): 280 if self._real_size <= 0: 281 raise FIFOIsEmpty() 282 283 result = self._l.popleft() 284 # result_len = self._l_length.popleft() 285 result_len = len(result) 286 self._real_size -= 1 287 self._data_full_size -= result_len 288 self._external_data_full_size.value -= result_len 289 290 return result
def
get_at_least_size(self, minimum_data_size):
292 def get_at_least_size(self, minimum_data_size): 293 if self._real_size <= 0: 294 raise FIFOIsEmpty() 295 296 result_data = deque() 297 result_size = 0 298 result_qnt = 0 299 300 while self._real_size and (result_size < minimum_data_size): 301 another_piece = self._l.popleft() 302 result_data.append(another_piece) 303 self._real_size -= 1 304 # result_len = self._l_length.popleft() 305 result_len = len(another_piece) 306 self._data_full_size -= result_len 307 self._external_data_full_size.value -= result_len 308 result_size += result_len 309 result_qnt += 1 310 311 result = (result_data, result_size, result_qnt) 312 return result