# synchronize newly inserted ids from one table to the next
# TODO: this fires off more than needed, try to organize syncrules
# per table
- for m in util.reversed(list(mapper.iterate_to_root())):
+ for m in reversed(list(mapper.iterate_to_root())):
if m.__inherits_equated_pairs:
m.__synchronize_inherited(state)
allconds = []
start = False
- for mapper in util.reversed(list(self.iterate_to_root())):
+ for mapper in reversed(list(self.iterate_to_root())):
if mapper.local_table in tables:
start = True
if start and not mapper.single:
for task in tasks:
self.execute_save_steps(trans, task)
if isdelete is not False:
- for task in util.reversed(tasks):
+ for task in reversed(tasks):
self.execute_delete_steps(trans, task)
def save_objects(self, trans, task):
for dep in task.polymorphic_dependencies:
self.execute_dependency(trans, dep, False)
if isdelete is not False:
- for dep in util.reversed(list(task.polymorphic_dependencies)):
+ for dep in reversed(list(task.polymorphic_dependencies)):
self.execute_dependency(trans, dep, True)
def execute_cyclical_dependencies(self, trans, task, isdelete):
"""Dumps out a string representation of a UOWTask structure"""
-from sqlalchemy import util
from sqlalchemy.orm import unitofwork
from sqlalchemy.orm import util as mapperutil
for task in tasks:
self._execute(trans, task, False)
if isdelete is not False:
- for task in util.reversed(tasks):
+ for task in reversed(tasks):
self._execute(trans, task, True)
def _execute(self, trans, task, isdelete):
visitors.traverse(table, {'schema_visitor':True}, {'foreign_key':visit_foreign_key})
sequence = topological.sort(tuples, tables)
if reverse:
- return util.reversed(sequence)
+ return reversed(sequence)
else:
return sequence
"""
-from sqlalchemy import util
from sqlalchemy.exc import CircularDependencyError
__all__ = ['sort', 'sort_with_cycles', 'sort_as_tree']
# order of the list has no semantics for the algorithmic
independents = []
# in reverse topological order
- for node in util.reversed(nodes):
+ for node in reversed(nodes):
# nodes subtree and cycles contain the node itself
subtree = set([node])
if node.cycles is not None:
except ImportError:
import pickle
-try:
- reversed = __builtin__.reversed
-except AttributeError:
- def reversed(seq):
- i = len(seq) -1
- while i >= 0:
- yield seq[i]
- i -= 1
- raise StopIteration()
-
try:
# Try the standard decimal for > 2.3 or the compatibility module
# for 2.3, if installed.