cengal.data_containers.stack.versions.v_0.stack
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 typing import Any, Optional, Callable, Union 19from collections import deque 20 21""" 22Module Docstring 23Docstrings: http://www.python.org/dev/peps/pep-0257/ 24""" 25 26__author__ = "ButenkoMS <gtalk@butenkoms.space>" 27__copyright__ = "Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>" 28__credits__ = ["ButenkoMS <gtalk@butenkoms.space>", ] 29__license__ = "Apache License, Version 2.0" 30__version__ = "4.4.1" 31__maintainer__ = "ButenkoMS <gtalk@butenkoms.space>" 32__email__ = "gtalk@butenkoms.space" 33# __status__ = "Prototype" 34__status__ = "Development" 35# __status__ = "Production" 36 37 38class TreeStackItem: 39 __slots__ = ('node', 'child') 40 41 def __init__(self, node: Any, child: Optional[int]=None): 42 self.node = node # container 43 self.child = child # an item id in container 44 45 46class DeepTreeStackItem(TreeStackItem): 47 __slots__ = ('node', 'child', 'deep') 48 49 def __init__(self, deep: int, node: Any, child: Optional[int] = None): 50 super().__init__(node, child) 51 self.deep: int = deep 52 53 54StackItem = Union[TreeStackItem, DeepTreeStackItem, Any] 55 56 57class Stack: 58 def __init__(self, initial_state: Optional[StackItem]=None): 59 self._stack = deque() 60 if initial_state: 61 self.push(initial_state) 62 63 def push(self, state: StackItem): 64 self._stack.append(state) 65 66 def pop(self) -> StackItem: 67 return self._stack.pop() 68 69 def top(self) -> StackItem: 70 return self._stack[-1] 71 72 def __len__(self): 73 return len(self._stack) 74 75 76class StackUni(Stack): 77 def __init__(self, initial_state: Optional[StackItem]=None, remove_on_pop: bool=True): 78 super(StackUni, self).__init__(initial_state) 79 self._stack = deque() 80 self._stack_top = -1 81 self._remove_on_pop = remove_on_pop 82 if self._remove_on_pop: 83 self.push = self._push_remove 84 self.pop = self._pop_remove 85 self.top = self._top_remove 86 self._len__impl = self._len__impl_remove 87 else: 88 self.push = self._push_keep 89 self.pop = self._pop_keep 90 self.top = self._top_keep 91 self._len__impl = self._len__impl_keep 92 93 if initial_state: 94 self.push(initial_state) 95 96 def _push_remove(self, state: StackItem): 97 self._stack.append(state) 98 99 def _pop_remove(self) -> StackItem: 100 return self._stack.pop() 101 102 def _top_remove(self) -> StackItem: 103 return self._stack[-1] 104 105 def _push_keep(self, state: StackItem): 106 # print('_push_keep: {}'.format(self._stack_top)) 107 self._stack_top += 1 108 if len(self._stack) > self._stack_top: 109 # we are not on a real top 110 self._stack[self._stack_top] = state 111 else: 112 # We are on the real top - need to increase stack size 113 self._stack.append(state) 114 115 def _pop_keep(self) -> StackItem: 116 # print('_pop_keep: {}'.format(self._stack_top)) 117 result = self._stack[self._stack_top] 118 self._stack_top -= 1 119 return result 120 121 def _top_keep(self) -> StackItem: 122 # print('_top_keep: {}'.format(self._stack_top)) 123 return self._stack[self._stack_top] 124 125 def _len__impl_remove(self): 126 return len(self._stack) 127 128 def _len__impl_keep(self): 129 return self._stack_top + 1 130 131 def __len__(self): 132 return self._len__impl() 133 134 135def recursion_insureness(recursive_functor: Callable, 136 stack_based_functor: Callable, 137 on_changed_to_drop_in_replacement: Optional[Callable], 138 *args, **kwargs): 139 try: 140 return recursive_functor(*args, **kwargs) 141 except RecursionError: 142 pass 143 144 if on_changed_to_drop_in_replacement: 145 on_changed_to_drop_in_replacement() 146 return stack_based_functor(*args, **kwargs) 147 148 149recursion_drop_in_replacement = recursion_insureness 150recursion_fallback_to_stack_based = recursion_insureness
class
TreeStackItem:
39class TreeStackItem: 40 __slots__ = ('node', 'child') 41 42 def __init__(self, node: Any, child: Optional[int]=None): 43 self.node = node # container 44 self.child = child # an item id in container
47class DeepTreeStackItem(TreeStackItem): 48 __slots__ = ('node', 'child', 'deep') 49 50 def __init__(self, deep: int, node: Any, child: Optional[int] = None): 51 super().__init__(node, child) 52 self.deep: int = deep
StackItem =
typing.Union[TreeStackItem, DeepTreeStackItem, typing.Any]
class
Stack:
58class Stack: 59 def __init__(self, initial_state: Optional[StackItem]=None): 60 self._stack = deque() 61 if initial_state: 62 self.push(initial_state) 63 64 def push(self, state: StackItem): 65 self._stack.append(state) 66 67 def pop(self) -> StackItem: 68 return self._stack.pop() 69 70 def top(self) -> StackItem: 71 return self._stack[-1] 72 73 def __len__(self): 74 return len(self._stack)
Stack( initial_state: typing.Union[TreeStackItem, DeepTreeStackItem, typing.Any, NoneType] = None)
77class StackUni(Stack): 78 def __init__(self, initial_state: Optional[StackItem]=None, remove_on_pop: bool=True): 79 super(StackUni, self).__init__(initial_state) 80 self._stack = deque() 81 self._stack_top = -1 82 self._remove_on_pop = remove_on_pop 83 if self._remove_on_pop: 84 self.push = self._push_remove 85 self.pop = self._pop_remove 86 self.top = self._top_remove 87 self._len__impl = self._len__impl_remove 88 else: 89 self.push = self._push_keep 90 self.pop = self._pop_keep 91 self.top = self._top_keep 92 self._len__impl = self._len__impl_keep 93 94 if initial_state: 95 self.push(initial_state) 96 97 def _push_remove(self, state: StackItem): 98 self._stack.append(state) 99 100 def _pop_remove(self) -> StackItem: 101 return self._stack.pop() 102 103 def _top_remove(self) -> StackItem: 104 return self._stack[-1] 105 106 def _push_keep(self, state: StackItem): 107 # print('_push_keep: {}'.format(self._stack_top)) 108 self._stack_top += 1 109 if len(self._stack) > self._stack_top: 110 # we are not on a real top 111 self._stack[self._stack_top] = state 112 else: 113 # We are on the real top - need to increase stack size 114 self._stack.append(state) 115 116 def _pop_keep(self) -> StackItem: 117 # print('_pop_keep: {}'.format(self._stack_top)) 118 result = self._stack[self._stack_top] 119 self._stack_top -= 1 120 return result 121 122 def _top_keep(self) -> StackItem: 123 # print('_top_keep: {}'.format(self._stack_top)) 124 return self._stack[self._stack_top] 125 126 def _len__impl_remove(self): 127 return len(self._stack) 128 129 def _len__impl_keep(self): 130 return self._stack_top + 1 131 132 def __len__(self): 133 return self._len__impl()
StackUni( initial_state: typing.Union[TreeStackItem, DeepTreeStackItem, typing.Any, NoneType] = None, remove_on_pop: bool = True)
78 def __init__(self, initial_state: Optional[StackItem]=None, remove_on_pop: bool=True): 79 super(StackUni, self).__init__(initial_state) 80 self._stack = deque() 81 self._stack_top = -1 82 self._remove_on_pop = remove_on_pop 83 if self._remove_on_pop: 84 self.push = self._push_remove 85 self.pop = self._pop_remove 86 self.top = self._top_remove 87 self._len__impl = self._len__impl_remove 88 else: 89 self.push = self._push_keep 90 self.pop = self._pop_keep 91 self.top = self._top_keep 92 self._len__impl = self._len__impl_keep 93 94 if initial_state: 95 self.push(initial_state)
def
recursion_insureness( recursive_functor: typing.Callable, stack_based_functor: typing.Callable, on_changed_to_drop_in_replacement: typing.Union[typing.Callable, NoneType], *args, **kwargs):
136def recursion_insureness(recursive_functor: Callable, 137 stack_based_functor: Callable, 138 on_changed_to_drop_in_replacement: Optional[Callable], 139 *args, **kwargs): 140 try: 141 return recursive_functor(*args, **kwargs) 142 except RecursionError: 143 pass 144 145 if on_changed_to_drop_in_replacement: 146 on_changed_to_drop_in_replacement() 147 return stack_based_functor(*args, **kwargs)
def
recursion_drop_in_replacement( recursive_functor: typing.Callable, stack_based_functor: typing.Callable, on_changed_to_drop_in_replacement: typing.Union[typing.Callable, NoneType], *args, **kwargs):
136def recursion_insureness(recursive_functor: Callable, 137 stack_based_functor: Callable, 138 on_changed_to_drop_in_replacement: Optional[Callable], 139 *args, **kwargs): 140 try: 141 return recursive_functor(*args, **kwargs) 142 except RecursionError: 143 pass 144 145 if on_changed_to_drop_in_replacement: 146 on_changed_to_drop_in_replacement() 147 return stack_based_functor(*args, **kwargs)
def
recursion_fallback_to_stack_based( recursive_functor: typing.Callable, stack_based_functor: typing.Callable, on_changed_to_drop_in_replacement: typing.Union[typing.Callable, NoneType], *args, **kwargs):
136def recursion_insureness(recursive_functor: Callable, 137 stack_based_functor: Callable, 138 on_changed_to_drop_in_replacement: Optional[Callable], 139 *args, **kwargs): 140 try: 141 return recursive_functor(*args, **kwargs) 142 except RecursionError: 143 pass 144 145 if on_changed_to_drop_in_replacement: 146 on_changed_to_drop_in_replacement() 147 return stack_based_functor(*args, **kwargs)