Skip to content

Commit 1497791

Browse files
emptybuttonemptybutton
committed
ref(Horiozn): remove useless code of previous environments
1 parent 1384990 commit 1497791

File tree

9 files changed

+692
-1032
lines changed

9 files changed

+692
-1032
lines changed

‎src/tgdb/entities/horizon/horizon.py‎

Lines changed: 100 additions & 155 deletions
Original file line numberDiff line numberDiff line change
@@ -1,208 +1,153 @@
11
from collections import OrderedDict
2+
from collections.abc import Sequence
23
from dataclasses import dataclass
34
from uuid import UUID
45

5-
from tgdb.entities.horizon.operator import (
6-
AppliedOperator,
7-
CommitOperator,
8-
IntermediateOperator,
9-
Operator,
10-
RollbackOperator,
11-
StartOperator,
6+
from tgdb.entities.horizon.effect import (
7+
Claim,
8+
DeletedTuple,
9+
MutatedTuple,
10+
NewTuple,
11+
ViewedTuple,
1212
)
1313
from tgdb.entities.horizon.transaction import (
14-
NoTransaction,
1514
Transaction,
1615
TransactionCommit,
16+
TransactionIsolation,
1717
TransactionOkPreparedCommit,
1818
TransactionPreparedCommit,
1919
TransactionState,
2020
start_transaction,
2121
)
22-
from tgdb.entities.time.logic_time import LogicTime, age
2322
from tgdb.entities.tools.assert_ import not_none
2423

2524

26-
class NonLinearizedOperatorError(Exception): ...
25+
class NoTransactionError(Exception): ...
2726

2827

29-
class UnlimitedHorizonError(Exception): ...
30-
31-
32-
class UnattainableHorizonError(Exception): ...
33-
34-
35-
class UselessMaxHeightError(Exception): ...
28+
class InvalidTransactionStateError(Exception): ...
3629

3730

3831
@dataclass
3932
class Horizon:
40-
_max_width: LogicTime | None
41-
_max_height: int | None
42-
_time: LogicTime | None
43-
_active_transaction_by_id: OrderedDict[UUID, Transaction]
44-
45-
def __post_init__(self) -> None:
46-
"""
47-
:raises tgdb.entities.horizon.horizon.UnlimitedHorizonError:
48-
:raises tgdb.entities.horizon.horizon.UnattainableHorizonError:
49-
:raises tgdb.entities.horizon.horizon.UselessMaxHeightError:
50-
"""
51-
52-
if self._max_width is None and self._max_height is None:
53-
raise UnlimitedHorizonError
54-
55-
if self._max_width is not None and self._max_width <= 0:
56-
raise UnattainableHorizonError
57-
58-
if self._max_height is not None and self._max_height <= 0:
59-
raise UnattainableHorizonError
60-
61-
if (
62-
self._max_height is not None and self._max_width is not None
63-
and self._max_width < self._max_height
64-
):
65-
raise UselessMaxHeightError
33+
_max_len: int
34+
_transaction_map: OrderedDict[UUID, Transaction]
6635

6736
def __bool__(self) -> bool:
68-
return bool(self._active_transaction_by_id)
69-
70-
def height(self) -> int:
71-
return len(self._active_transaction_by_id)
72-
73-
def width(self) -> LogicTime:
74-
return age(self.beginning(), self.time())
37+
return bool(self._transaction_map)
7538

76-
def time(self) -> LogicTime | None:
77-
return self._time
39+
def __len__(self) -> int:
40+
return len(self._transaction_map)
7841

79-
def beginning(self) -> LogicTime | None:
80-
oldest_transaction = self._oldest_transaction()
81-
82-
if oldest_transaction is None:
83-
return None
42+
def start_transaction(
43+
self,
44+
transaction_id: UUID,
45+
transaction_isolation: TransactionIsolation,
46+
) -> Transaction:
47+
"""
48+
:raises tgdb.entities.horizon.horizon.InvalidTransactionStateError:
49+
"""
8450

85-
return oldest_transaction.beginning()
51+
if transaction_id in self._transaction_map:
52+
raise InvalidTransactionStateError
8653

87-
def complete(
88-
self, prepared_commit: TransactionOkPreparedCommit
89-
) -> TransactionCommit | None:
90-
transaction = self._active_transaction_by_id.get(
91-
prepared_commit.transaction_id
54+
new_transaction = start_transaction(
55+
transaction_id,
56+
transaction_isolation,
57+
self._transaction_map.values(),
9258
)
59+
self._transaction_map[new_transaction.id()] = new_transaction
60+
self._limit_len()
9361

94-
if (
95-
transaction is None
96-
or transaction.state() is not TransactionState.prepared
97-
):
98-
return None
62+
return new_transaction
9963

100-
commit = transaction.commit()
101-
del self._active_transaction_by_id[transaction.id()]
102-
103-
return commit
104-
105-
def add(
106-
self, applied_operator: AppliedOperator
107-
) -> TransactionPreparedCommit | None:
64+
def view_tuple(
65+
self,
66+
transaction_id: UUID,
67+
effect: ViewedTuple,
68+
) -> None:
10869
"""
109-
:raises tgdb.entities.horizon.horizon.NonLinearizedOperatorError:
70+
:raises tgdb.entities.horizon.horizon.NoTransactionError:
71+
:raises tgdb.entities.horizon.horizon.InvalidTransactionStateError:
11072
"""
11173

112-
if self._time is not None and applied_operator.time <= self._time:
113-
raise NonLinearizedOperatorError
114-
115-
self._time = applied_operator.time
116-
117-
return self._add_operator(applied_operator.operator)
74+
transaction = self._transaction(transaction_id, TransactionState.active)
75+
transaction.include(effect)
11876

119-
def _add_operator(
120-
self, operator: Operator
121-
) -> TransactionPreparedCommit | None:
122-
transaction = self._active_transaction_by_id.get(
123-
operator.transaction_id
124-
)
125-
state = None if transaction is None else transaction.state
126-
127-
match operator, transaction, state:
128-
case StartOperator(), None, _:
129-
self._start_transaction(operator)
130-
131-
case RollbackOperator(), Transaction(), TransactionState.active:
132-
self._rollback(transaction)
133-
return None
77+
def rollback_transaction(self, transaction_id: UUID) -> None:
78+
"""
79+
:raises tgdb.entities.horizon.horizon.NoTransactionError:
80+
"""
13481

135-
case (
136-
IntermediateOperator(_, effect),
137-
Transaction(),
138-
TransactionState.active
139-
):
140-
transaction.include(effect)
82+
transaction = self._transaction(transaction_id)
83+
transaction.rollback()
84+
del self._transaction_map[transaction.id()]
14185

142-
case (
143-
CommitOperator(_, intermediate_operators),
144-
Transaction(),
145-
TransactionState.active
146-
):
147-
for intermediate_operator in intermediate_operators:
148-
transaction.include(intermediate_operator.effect)
86+
def commit_transaction(
87+
self,
88+
transaction_id: UUID,
89+
effects: Sequence[NewTuple | MutatedTuple | DeletedTuple | Claim],
90+
) -> TransactionPreparedCommit:
91+
"""
92+
:raises tgdb.entities.horizon.horizon.NoTransactionError:
93+
:raises tgdb.entities.horizon.horizon.InvalidTransactionStateError:
94+
"""
14995

150-
return transaction.prepare_commit()
96+
transaction = self._transaction(transaction_id, TransactionState.active)
15197

152-
case CommitOperator(), None, _:
153-
return NoTransaction(operator.transaction_id)
98+
for effect in effects:
99+
transaction.include(effect)
154100

155-
case _:
156-
...
101+
return transaction.prepare_commit()
157102

158-
return None
103+
def complete_commit(
104+
self, prepared_commit: TransactionOkPreparedCommit
105+
) -> TransactionCommit:
106+
"""
107+
:raises tgdb.entities.horizon.horizon.NoTransactionError:
108+
:raises tgdb.entities.horizon.horizon.InvalidTransactionStateError:
109+
"""
159110

160-
def _start_transaction(self, operator: StartOperator) -> None:
161-
new_transaction = start_transaction(
162-
operator.transaction_id,
163-
operator.transaction_isolation,
164-
self._active_transaction_by_id.values(),
165-
not_none(self._time),
111+
transaction = self._transaction(
112+
prepared_commit.transaction_id,
113+
TransactionState.prepared,
166114
)
167-
self._active_transaction_by_id[new_transaction.id()] = new_transaction
168-
169-
self._limit_size()
170115

171-
def _limit_size(self) -> None:
172-
too_wide = (
173-
self._max_width is not None and self.width() > self._max_width
174-
)
175-
too_high = (
176-
self._max_height is not None and self.height() > self._max_height
177-
)
116+
commit = transaction.commit()
117+
del self._transaction_map[transaction.id()]
178118

179-
if too_wide or too_high:
180-
self._rollback(not_none(self._oldest_transaction()))
119+
return commit
181120

182-
def _rollback(self, transaction: Transaction) -> None:
183-
del self._active_transaction_by_id[transaction.id()]
184-
transaction.rollback()
121+
def _limit_len(self) -> None:
122+
if len(self) > self._max_len:
123+
transaction = not_none(self._oldest_transaction())
124+
transaction.rollback()
125+
del self._transaction_map[transaction.id()]
185126

186127
def _oldest_transaction(self) -> Transaction | None:
187128
try:
188-
return next(iter(self._active_transaction_by_id.values()))
129+
return next(iter(self._transaction_map.values()))
189130
except StopIteration:
190131
return None
191132

133+
def _transaction(
134+
self, id: UUID, state: TransactionState | None = None
135+
) -> Transaction:
136+
"""
137+
:raises tgdb.entities.horizon.horizon.NoTransactionError:
138+
:raises tgdb.entities.horizon.horizon.InvalidTransactionStateError:
139+
"""
140+
141+
transaction = self._transaction_map.get(id)
142+
143+
if transaction is None:
144+
raise NoTransactionError
145+
146+
if state is not None and transaction.state() is not state:
147+
raise InvalidTransactionStateError
148+
149+
return transaction
150+
192151

193-
def create_horizon(
194-
max_width: LogicTime | None,
195-
max_height: int | None,
196-
) -> Horizon:
197-
"""
198-
:raises tgdb.entities.horizon.horizon.UnlimitedHorizonError:
199-
:raises tgdb.entities.horizon.horizon.UnattainableHorizonError:
200-
:raises tgdb.entities.horizon.horizon.UselessMaxHeightError:
201-
"""
202-
203-
return Horizon(
204-
_max_width=max_width,
205-
_max_height=max_height,
206-
_time=None,
207-
_active_transaction_by_id=OrderedDict(),
208-
)
152+
def horizon(max_len: int) -> Horizon:
153+
return Horizon(_max_len=max_len, _transaction_map=OrderedDict())

‎src/tgdb/entities/horizon/operator.py‎

Lines changed: 0 additions & 57 deletions
This file was deleted.

0 commit comments

Comments
 (0)