cengal.data_containers.fast_fifo.versions.v_0.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
 19from cengal.code_flow_control.smart_values.versions.v_0 import ResultCache, ResultExistence
 20from cengal.code_inspection.line_profiling import set_profiler
 21
 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: ResultExistence=None,
111                 external_deletable_data_full_size: ResultExistence=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 = ResultCache()
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 ResultExistence(False, 0)
126        self._external_deletable_data_full_size = external_deletable_data_full_size or ResultExistence(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.result += data_size
137        self._external_data_full_size.result += 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.result += full_size_diff
158        self._external_data_full_size.result += 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.result += 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.result -= self._deletable_data_full_size
183            self._external_data_full_size.result -= 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.result -= 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.result += 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.result -= self._deletable_data_full_size
206            self._external_data_full_size.result -= 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.result -= 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.result
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.result += 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.result
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.result -= self._data_full_size.result
232            self._external_deletable_data_full_size.result -= 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: ResultExistence=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 ResultExistence(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.result += 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.result += 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.result -= 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.result -= 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.result -= 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): 
47class FIFOIsEmpty(Exception):
48    pass

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)
FIFO(on_hold_limit=None) 
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
def put(self, data): 
61    def put(self, data):
62        self._l.append(data)
63        self._useful_size += 1
64        self._real_size += 1
def extend(self, iterable_data): 
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
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
def size(self): 
96    def size(self):
97        return self._useful_size
def full_size(self): 
 99    def full_size(self):
100        return self._real_size
def remove(self): 
102    def remove(self):
103        pass
class FIFOWithLengthControl(FIFO): 
109class FIFOWithLengthControl(FIFO):
110    def __init__(self, on_hold_limit=None, on_hold_data_size_limit=None,
111                 external_data_full_size: ResultExistence=None,
112                 external_deletable_data_full_size: ResultExistence=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 = ResultCache()
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 ResultExistence(False, 0)
127        self._external_deletable_data_full_size = external_deletable_data_full_size or ResultExistence(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.result += data_size
138        self._external_data_full_size.result += 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.result += full_size_diff
159        self._external_data_full_size.result += 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.result += 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.result -= self._deletable_data_full_size
184            self._external_data_full_size.result -= 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.result -= 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.result += 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.result -= self._deletable_data_full_size
207            self._external_data_full_size.result -= 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.result -= 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.result
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.result += 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.result
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.result -= self._data_full_size.result
233            self._external_deletable_data_full_size.result -= 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_0.result_types.ResultExistence = None, external_deletable_data_full_size: cengal.code_flow_control.smart_values.versions.v_0.result_types.ResultExistence = None) 
110    def __init__(self, on_hold_limit=None, on_hold_data_size_limit=None,
111                 external_data_full_size: ResultExistence=None,
112                 external_deletable_data_full_size: ResultExistence=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 = ResultCache()
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 ResultExistence(False, 0)
127        self._external_deletable_data_full_size = external_deletable_data_full_size or ResultExistence(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.result += data_size
138        self._external_data_full_size.result += 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.result += full_size_diff
159        self._external_data_full_size.result += 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.result += 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.result -= self._deletable_data_full_size
184            self._external_data_full_size.result -= 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.result -= self._deletable_data_full_size
190            self._deletable_data_full_size = 0
191        return result
def get_data_full_size(self): 
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.result
def get_deletable_data_full_size(self): 
227    def get_deletable_data_full_size(self):
228        return self._deletable_data_full_size
def remove(self): 
230    def remove(self):
231        if not self._removed:
232            self._external_data_full_size.result -= self._data_full_size.result
233            self._external_deletable_data_full_size.result -= self._deletable_data_full_size
234            self._removed = True
Inherited Members
class FIFODequeWithLengthControl: 
246class FIFODequeWithLengthControl:
247    def __init__(self, external_data_full_size: ResultExistence=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 ResultExistence(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.result += 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.result += 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.result -= 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.result -= 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.result -= 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_0.result_types.ResultExistence = None) 
247    def __init__(self, external_data_full_size: ResultExistence=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 ResultExistence(False, 0)
def put(self, data): 
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.result += data_size
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.result += 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.result -= 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.result -= result_len
308            result_size += result_len
309            result_qnt += 1
310
311        result = (result_data, result_size, result_qnt)
312        return result
def get_data_full_size(self): 
314    def get_data_full_size(self):
315        return self._data_full_size
def remove(self): 
317    def remove(self):
318        if not self._removed:
319            self._external_data_full_size.result -= self._data_full_size
320            self._removed = True
def size(self): 
328    def size(self):
329        return self._real_size
def full_size(self): 
331    def full_size(self):
332        return self._real_size