Set private ``_search_range`` and reset ``_block_matcher``.
435969
def search_range(self, value):
        """"""
        if value == 0 or not value % 16:
            self._search_range = value
        else:
            raise InvalidSearchRangeError("Search range must be a multiple of "
                                          "16.")
        self._replace_bm()
719756
def setNumberRange(key, keyType, start, end):
    ''''''
    return And(
        And(keyType, error=SCHEMA_TYPE_ERROR % (key, keyType.__name__)),
        And(lambda n: start <= n <= end, error=SCHEMA_RANGE_ERROR % (key, '(%s,%s)' % (start, end))),
    )
1069394
def check_range_key(query_on, key):
    """"""
    return (
        isinstance(key, BaseCondition) and
        key.operation in ("begins_with", "between", "<", ">", "<=", ">=", "==") and
        key.column is query_on.range_key
    )
280868
def set_recovery_range(working_dir, start_block, end_block):
    
    recovery_range_path = os.path.join(working_dir, '.recovery')
    with open(recovery_range_path, 'w') as f:
        f.write('{}\n{}\n'.format(start_block, end_block))
        f.flush()
        os.fsync(f.fileno())
44070
def reset_alarm_ranges(self, parameter):
        
        req = mdb_pb2.ChangeParameterRequest()
        req.action = mdb_pb2.ChangeParameterRequest.RESET_ALARMS        
        
        url = '/mdb/{}/{}/parameters/{}'.format(
            self._instance, self._processor, parameter)
        response = self._client.post_proto(url, data=req.SerializeToString())
656255
def set_bind(self):
        
        RangedInt.set_bind(self)
        self.unbind('<Next>')
        self.unbind('<Prior>')
        self.bind('<Next>', lambda e: self.set(self._min()))
        self.bind('<Prior>', lambda e: self.set(self._max()))
347646
function Range(min, max, step) {
  var scope = null
    , re = /^([A-Za-z]|\d+)\.{2}([A-Za-z]|\d+)$/;

  if (typeof min === 'string' && min.match(re)) {
    step = max;
    scope = min.split('..');
    min = cast(scope[0]);
    max = cast(scope[1]);
  }

  this.min(min);
  this.max(max);
  this.step(step);
}
396770
function rangeFromMatch(match) {
        var wrappers = getWrappersByIndex(indexOf(match));

        var rng = editor.dom.createRng();
        rng.setStartBefore(wrappers[0]);
        rng.setEndAfter(wrappers[wrappers.length - 1]);

        return rng;
      }
578543
def search_range(nums, target):
    
    low = 0
    high = len(nums) - 1
    while low <= high:
        mid = low + (high - low) // 2
        if target < nums[mid]:
            high = mid - 1
        elif target > nums[mid]:
            low = mid + 1
        else:
            break

    for j in range(len(nums) - 1, -1, -1):
        if nums[j] == target:
            return [mid, j]

    return [-1, -1]
450325
def _clean(cls, value, invalid):
        """"""
        cls._deprecation_warning()
        return BlockUsageLocator._clean(value, invalid)
890269
def set_range(self, start=None, end=None, occurrences=None):
        
        if start is None:
            if self.__start_date is None:
                self.__start_date = dt.date.today()
        else:
            self.start_date = start

        if end:
            self.end_date = end
        elif occurrences:
            self.__occurrences = occurrences
        self._track_changes()
1359450
def set_range(self, start_index=0, end_index=None):
        '''
        
        '''
        if end_index is not None:
            end_index += 1
        self._test_list = StartEndList(start_index, end_index)
        self.session_info.start_index = start_index
        self.session_info.current_index = 0
        self.session_info.end_index = end_index
        self.session_info.test_list_str = self._test_list.as_test_list_str()
        return self
705865
def copy_reset(self):
        """"""
        # Reset settings
        self._filters = []
        self._filter_or = False
        self._paginate = True
        self._paginate_count = 0
        self._result_count = None
        self._result_limit = 500
        self._result_start = 0
1335988
def add_range(self, start, stop, step=1, pad=0):
        
        assert start < stop, "please provide ordered node index ranges"
        assert step > 0
        assert pad >= 0
        assert stop - start < 1e9, "range too large"

        if pad > 0 and self.padding is None:
            self.padding = pad
        set.update(self, range(start, stop, step))
784784
def skip_until(self, regex):
        
        return self.search_full(regex, return_string=False, advance_pointer=True)
383050
def fix_line_range(source_code, start, end, options):
    """"""
    # TODO confirm behaviour outside range (indexing starts at 1)
    start = max(start, 1)

    options.line_range = [start, end]
    from autopep8 import fix_code
    fixed = fix_code(source_code, options)

    try:
        if options.docformatter:
            from docformatter import format_code
            fixed = format_code(
                fixed,
                summary_wrap_length=options.max_line_length - 1,
                description_wrap_length=(options.max_line_length
                                         - 2 * options.indent_size),
                pre_summary_newline=options.pre_summary_newline,
                post_description_blank=options.post_description_blank,
                force_wrap=options.force_wrap,
                line_range=[start, end])
    except AttributeError:  # e.g. using autopep8.parse_args, pragma: no cover
        pass

    return fixed
186229
public static function reset($range = null)
    {
        static::_init();
        
        $range = $range ?: self::$range;
        if (true === $range) {
            self::$data->clear();
        } else {
            self::$data->set($range, []);
        }
    }