File Manager

X7ROOT File Manager

Current Path: /lib/python2.7/site-packages/pip/_vendor/idna

lib / python2.7 / site-packages / pip / _vendor / idna /

?? ..
?? __init__.py(58 B)
?? __init__.pyc(244 B)
?? __init__.pyo(244 B)
?? codec.py(3.22 KB)
?? codec.pyc(3.88 KB)
?? codec.pyo(3.88 KB)
?? compat.py(232 B)
?? compat.pyc(811 B)
?? compat.pyo(811 B)
?? core.py(11.12 KB)
?? core.pyc(11.5 KB)
?? core.pyo(11.5 KB)
?? idnadata.py(32.23 KB)
?? idnadata.pyc(27.89 KB)
?? idnadata.pyo(27.89 KB)
?? intranges.py(1.71 KB)
?? intranges.pyc(2.17 KB)
?? intranges.pyo(2.17 KB)
?? package_data.py(21 B)
?? package_data.pyc(182 B)
?? package_data.pyo(182 B)
?? uts46data.py(180.61 KB)
?? uts46data.pyc(267.14 KB)
?? uts46data.pyo(267.14 KB)

Editing: intranges.py

"""
Given a list of integers, made up of (hopefully) a small number of long runs
of consecutive integers, compute a representation of the form
((start1, end1), (start2, end2) ...). Then answer the question "was x present
in the original list?" in time O(log(# runs)).
"""

import bisect

def intranges_from_list(list_):
    """Represent a list of integers as a sequence of ranges:
    ((start_0, end_0), (start_1, end_1), ...), such that the original
    integers are exactly those x such that start_i <= x < end_i for some i.

Ranges are encoded as single integers (start << 32 | end), not as tuples.
    """

sorted_list = sorted(list_)
    ranges = []
    last_write = -1
    for i in range(len(sorted_list)):
        if i+1 < len(sorted_list):
            if sorted_list[i] == sorted_list[i+1]-1:
                continue
        current_range = sorted_list[last_write+1:i+1]
        ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
        last_write = i

return tuple(ranges)

def _encode_range(start, end):
    return (start << 32) | end

def _decode_range(r):
    return (r >> 32), (r & ((1 << 32) - 1))

def intranges_contain(int_, ranges):
    """Determine if `int_` falls into one of the ranges in `ranges`."""
    tuple_ = _encode_range(int_, 0)
    pos = bisect.bisect_left(ranges, tuple_)
    # we could be immediately ahead of a tuple (start, end)
    # with start < int_ <= end
    if pos > 0:
        left, right = _decode_range(ranges[pos-1])
        if left <= int_ < right:
            return True
    # or we could be immediately behind a tuple (int_, end)
    if pos < len(ranges):
        left, _ = _decode_range(ranges[pos])
        if left == int_:
            return True
    return False

X7ROOT File Manager

Editing: intranges.py

Upload File

Create Folder