cengal.data_containers.stack.versions.v_0.stack

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
 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: View Source

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

TreeStackItem(node: typing.Any, child: typing.Union[int, NoneType] = None) View Source

42    def __init__(self, node: Any, child: Optional[int]=None):
43        self.node = node  # container
44        self.child = child  # an item id in container

node

child

class DeepTreeStackItem(TreeStackItem): View Source

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

DeepTreeStackItem( deep: int, node: typing.Any, child: typing.Union[int, NoneType] = None) View Source

50    def __init__(self, deep: int, node: Any, child: Optional[int] = None):
51        super().__init__(node, child)
52        self.deep: int = deep

deep: int

node

child

StackItem = typing.Union[TreeStackItem, DeepTreeStackItem, typing.Any]

class Stack: View Source

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) View Source

59    def __init__(self, initial_state: Optional[StackItem]=None):
60        self._stack = deque()
61        if initial_state:
62            self.push(initial_state)

def push( self, state: typing.Union[TreeStackItem, DeepTreeStackItem, typing.Any]): View Source

64    def push(self, state: StackItem):
65        self._stack.append(state)

def pop( self) -> Union[TreeStackItem, DeepTreeStackItem, Any]: View Source

67    def pop(self) -> StackItem:
68        return self._stack.pop()

def top( self) -> Union[TreeStackItem, DeepTreeStackItem, Any]: View Source

70    def top(self) -> StackItem:
71        return self._stack[-1]

class StackUni(Stack): View Source

 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) View Source

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)

Inherited Members

Stack

push

pop

top

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): View Source

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): View Source

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): View Source

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)