cengal.data_containers.limitable_dict_with_order.versions.v_1.limitable_dict_with_order

View Source

 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
18
19__all__ = ['LimitableDictWithOrder']
20
21
22"""
23Module Docstring
24Docstrings: http://www.python.org/dev/peps/pep-0257/
25"""
26
27__author__ = "ButenkoMS <gtalk@butenkoms.space>"
28__copyright__ = "Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>"
29__credits__ = ["ButenkoMS <gtalk@butenkoms.space>", ]
30__license__ = "Apache License, Version 2.0"
31__version__ = "4.4.1"
32__maintainer__ = "ButenkoMS <gtalk@butenkoms.space>"
33__email__ = "gtalk@butenkoms.space"
34# __status__ = "Prototype"
35__status__ = "Development"
36# __status__ = "Production"
37
38
39from cengal.code_flow_control.none_or import none_or
40from collections import UserDict
41from typing import Dict, List, Optional
42
43
44class LimitableDictWithOrder(UserDict):
45    def __init__(self, low_water: int, hi_water: int, data: Optional[Dict] = None, order: Optional[List] = None, sort_each_time: bool = False) -> None:
46        self.low_water: int = low_water if low_water >= 0 else 0
47        self.hi_water: int = hi_water if hi_water >= 0 else 0
48        # self.data: Optional[Dict] = none_or(data, dict())
49        self.order: Optional[List] = none_or(order, list())
50        self.sort_each_time: bool = sort_each_time
51        return super().__init__(none_or(data, dict()))
52    
53    def check_limits(self):
54        if len(self.order) <= self.hi_water:
55            return
56
57        keys_to_delete = self.order[:-self.low_water]
58        self.order = self.order[-self.low_water:]
59        for key in keys_to_delete:
60            self.data.pop(key, None)
61
62    def __call__(self):
63        return self.check_limits()
64
65    def __setitem__(self, key, value):
66        super().__setitem__(key, value)
67        self.order.append(key)
68        if self.sort_each_time:
69            self.order.sort()
70        
71        self.check_limits()

class LimitableDictWithOrder(collections.UserDict): View Source

45class LimitableDictWithOrder(UserDict):
46    def __init__(self, low_water: int, hi_water: int, data: Optional[Dict] = None, order: Optional[List] = None, sort_each_time: bool = False) -> None:
47        self.low_water: int = low_water if low_water >= 0 else 0
48        self.hi_water: int = hi_water if hi_water >= 0 else 0
49        # self.data: Optional[Dict] = none_or(data, dict())
50        self.order: Optional[List] = none_or(order, list())
51        self.sort_each_time: bool = sort_each_time
52        return super().__init__(none_or(data, dict()))
53    
54    def check_limits(self):
55        if len(self.order) <= self.hi_water:
56            return
57
58        keys_to_delete = self.order[:-self.low_water]
59        self.order = self.order[-self.low_water:]
60        for key in keys_to_delete:
61            self.data.pop(key, None)
62
63    def __call__(self):
64        return self.check_limits()
65
66    def __setitem__(self, key, value):
67        super().__setitem__(key, value)
68        self.order.append(key)
69        if self.sort_each_time:
70            self.order.sort()
71        
72        self.check_limits()

LimitableDictWithOrder( low_water: int, hi_water: int, data: typing.Union[typing.Dict, NoneType] = None, order: typing.Union[typing.List, NoneType] = None, sort_each_time: bool = False) View Source

46    def __init__(self, low_water: int, hi_water: int, data: Optional[Dict] = None, order: Optional[List] = None, sort_each_time: bool = False) -> None:
47        self.low_water: int = low_water if low_water >= 0 else 0
48        self.hi_water: int = hi_water if hi_water >= 0 else 0
49        # self.data: Optional[Dict] = none_or(data, dict())
50        self.order: Optional[List] = none_or(order, list())
51        self.sort_each_time: bool = sort_each_time
52        return super().__init__(none_or(data, dict()))

low_water: int

hi_water: int

order: Union[List, NoneType]

sort_each_time: bool

def check_limits(self): View Source

54    def check_limits(self):
55        if len(self.order) <= self.hi_water:
56            return
57
58        keys_to_delete = self.order[:-self.low_water]
59        self.order = self.order[-self.low_water:]
60        for key in keys_to_delete:
61            self.data.pop(key, None)

Inherited Members

collections.UserDict: data; copy; fromkeys
collections.abc.MutableMapping: pop; popitem; clear; update; setdefault
collections.abc.Mapping: get; keys; items; values