def bisect_right(self, val):
"""
Same as *bisect_left*, but if *val* is already present, the insertion
point will be after (to the right of) any existing entries.
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, val)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._lists[pos], val)
return self._loc(pos, idx)
python类bisect_right()的实例源码
def get_statement_startend2(lineno, node):
import ast
# flatten all statements and except handlers into one lineno-list
# AST's line numbers start indexing at 1
l = []
for x in ast.walk(node):
if isinstance(x, _ast.stmt) or isinstance(x, _ast.ExceptHandler):
l.append(x.lineno - 1)
for name in "finalbody", "orelse":
val = getattr(x, name, None)
if val:
# treat the finally/orelse part as its own statement
l.append(val[0].lineno - 1 - 1)
l.sort()
insert_index = bisect_right(l, lineno)
start = l[insert_index - 1]
if insert_index >= len(l):
end = None
else:
end = l[insert_index]
return start, end
def get_statement_startend2(lineno, node):
import ast
# flatten all statements and except handlers into one lineno-list
# AST's line numbers start indexing at 1
l = []
for x in ast.walk(node):
if isinstance(x, _ast.stmt) or isinstance(x, _ast.ExceptHandler):
l.append(x.lineno - 1)
for name in "finalbody", "orelse":
val = getattr(x, name, None)
if val:
# treat the finally/orelse part as its own statement
l.append(val[0].lineno - 1 - 1)
l.sort()
insert_index = bisect_right(l, lineno)
start = l[insert_index - 1]
if insert_index >= len(l):
end = None
else:
end = l[insert_index]
return start, end
def get_statement_startend2(lineno, node):
import ast
# flatten all statements and except handlers into one lineno-list
# AST's line numbers start indexing at 1
l = []
for x in ast.walk(node):
if isinstance(x, _ast.stmt) or isinstance(x, _ast.ExceptHandler):
l.append(x.lineno - 1)
for name in "finalbody", "orelse":
val = getattr(x, name, None)
if val:
# treat the finally/orelse part as its own statement
l.append(val[0].lineno - 1 - 1)
l.sort()
insert_index = bisect_right(l, lineno)
start = l[insert_index - 1]
if insert_index >= len(l):
end = None
else:
end = l[insert_index]
return start, end
def get_statement_startend2(lineno, node):
import ast
# flatten all statements and except handlers into one lineno-list
# AST's line numbers start indexing at 1
l = []
for x in ast.walk(node):
if isinstance(x, _ast.stmt) or isinstance(x, _ast.ExceptHandler):
l.append(x.lineno - 1)
for name in "finalbody", "orelse":
val = getattr(x, name, None)
if val:
# treat the finally/orelse part as its own statement
l.append(val[0].lineno - 1 - 1)
l.sort()
insert_index = bisect_right(l, lineno)
start = l[insert_index - 1]
if insert_index >= len(l):
end = None
else:
end = l[insert_index]
return start, end
def add(self, val):
"""Add the element *val* to the list."""
_lists = self._lists
_maxes = self._maxes
if _maxes:
pos = bisect_right(_maxes, val)
if pos == len(_maxes):
pos -= 1
_lists[pos].append(val)
_maxes[pos] = val
else:
insort(_lists[pos], val)
self._expand(pos)
else:
_lists.append([val])
_maxes.append(val)
self._len += 1
def bisect_right(self, val):
"""
Same as *bisect_left*, but if *val* is already present, the insertion
point will be after (to the right of) any existing entries.
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, val)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._lists[pos], val)
return self._loc(pos, idx)
def add(self, val):
"""Add the element *val* to the list."""
_lists = self._lists
_maxes = self._maxes
if _maxes:
pos = bisect_right(_maxes, val)
if pos == len(_maxes):
pos -= 1
_lists[pos].append(val)
_maxes[pos] = val
else:
insort(_lists[pos], val)
self._expand(pos)
else:
_lists.append([val])
_maxes.append(val)
self._len += 1
def bisect_right(self, val):
"""
Same as *bisect_left*, but if *val* is already present, the insertion
point will be after (to the right of) any existing entries.
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, val)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._lists[pos], val)
return self._loc(pos, idx)
util.py 文件源码
项目：PyDataLondon29-EmbarrassinglyParallelDAWithAWSLambda
作者: SignalMedia
项目源码
文件源码
阅读 20
收藏 0
点赞 0
评论 0
def iterate_from(self, start_tok):
piecenum = bisect.bisect_right(self._offsets, start_tok)-1
while piecenum < len(self._pieces):
offset = self._offsets[piecenum]
piece = self._pieces[piecenum]
# If we've got another piece open, close it first.
if self._open_piece is not piece:
if self._open_piece is not None:
self._open_piece.close()
self._open_piece = piece
# Get everything we can from this piece.
for tok in piece.iterate_from(max(0, start_tok-offset)):
yield tok
# Update the offset table.
if piecenum+1 == len(self._offsets):
self._offsets.append(self._offsets[-1] + len(piece))
# Move on to the next piece.
piecenum += 1
def add(self, val):
"""Add the element *val* to the list."""
_lists = self._lists
_maxes = self._maxes
if _maxes:
pos = bisect_right(_maxes, val)
if pos == len(_maxes):
pos -= 1
_lists[pos].append(val)
_maxes[pos] = val
else:
insort(_lists[pos], val)
self._expand(pos)
else:
_lists.append([val])
_maxes.append(val)
self._len += 1
def bisect_right(self, val):
"""
Same as *bisect_left*, but if *val* is already present, the insertion
point will be after (to the right of) any existing entries.
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, val)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._lists[pos], val)
return self._loc(pos, idx)
def add(self, val):
"""Add the element *val* to the list."""
_lists = self._lists
_maxes = self._maxes
if _maxes:
pos = bisect_right(_maxes, val)
if pos == len(_maxes):
pos -= 1
_lists[pos].append(val)
_maxes[pos] = val
else:
insort(_lists[pos], val)
self._expand(pos)
else:
_lists.append([val])
_maxes.append(val)
self._len += 1
def bisect_right(self, val):
"""
Same as *bisect_left*, but if *val* is already present, the insertion
point will be after (to the right of) any existing entries.
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, val)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._lists[pos], val)
return self._loc(pos, idx)
def __init__(self, table, key):
self._table = table
self._values = [] # ordered list of values
self._rec_by_val = [] # matching record numbers
self._records = {} # record numbers:values
self.__doc__ = key.__doc__ or 'unknown'
self._key = key
self._previous_status = []
for record in table:
value = key(record)
if value is DoNotIndex:
continue
rec_num = recno(record)
if not isinstance(value, tuple):
value = (value, )
vindex = bisect_right(self._values, value)
self._values.insert(vindex, value)
self._rec_by_val.insert(vindex, rec_num)
self._records[rec_num] = value
table._indexen.add(self)
def __call__(self, record):
rec_num = recno(record)
key = self.key(record)
if rec_num in self._records:
if self._records[rec_num] == key:
return
old_key = self._records[rec_num]
vindex = bisect_left(self._values, old_key)
self._values.pop(vindex)
self._rec_by_val.pop(vindex)
del self._records[rec_num]
assert rec_num not in self._records
if key == (DoNotIndex, ):
return
vindex = bisect_right(self._values, key)
self._values.insert(vindex, key)
self._rec_by_val.insert(vindex, rec_num)
self._records[rec_num] = key
def __init__(self, table, key):
self._table = table
self._values = [] # ordered list of values
self._rec_by_val = [] # matching record numbers
self._records = {} # record numbers:values
self.__doc__ = key.__doc__ or 'unknown'
self._key = key
self._previous_status = []
for record in table:
value = key(record)
if value is DoNotIndex:
continue
rec_num = recno(record)
if not isinstance(value, tuple):
value = (value, )
vindex = bisect_right(self._values, value)
self._values.insert(vindex, value)
self._rec_by_val.insert(vindex, rec_num)
self._records[rec_num] = value
table._indexen.add(self)
def __call__(self, record):
rec_num = recno(record)
key = self.key(record)
if rec_num in self._records:
if self._records[rec_num] == key:
return
old_key = self._records[rec_num]
vindex = bisect_left(self._values, old_key)
self._values.pop(vindex)
self._rec_by_val.pop(vindex)
del self._records[rec_num]
assert rec_num not in self._records
if key == (DoNotIndex, ):
return
vindex = bisect_right(self._values, key)
self._values.insert(vindex, key)
self._rec_by_val.insert(vindex, rec_num)
self._records[rec_num] = key
def __init__(self, table, key):
self._table = table
self._values = [] # ordered list of values
self._rec_by_val = [] # matching record numbers
self._records = {} # record numbers:values
self.__doc__ = key.__doc__ or 'unknown'
self._key = key
self._previous_status = []
for record in table:
value = key(record)
if value is DoNotIndex:
continue
rec_num = recno(record)
if not isinstance(value, tuple):
value = (value, )
vindex = bisect_right(self._values, value)
self._values.insert(vindex, value)
self._rec_by_val.insert(vindex, rec_num)
self._records[rec_num] = value
table._indexen.add(self)
def __call__(self, record):
rec_num = recno(record)
key = self.key(record)
if rec_num in self._records:
if self._records[rec_num] == key:
return
old_key = self._records[rec_num]
vindex = bisect_left(self._values, old_key)
self._values.pop(vindex)
self._rec_by_val.pop(vindex)
del self._records[rec_num]
assert rec_num not in self._records
if key == (DoNotIndex, ):
return
vindex = bisect_right(self._values, key)
self._values.insert(vindex, key)
self._rec_by_val.insert(vindex, rec_num)
self._records[rec_num] = key
