Initialize the StartRequest with start and stop needle.

        :raises TypeError: if the arguments are not integers
        :raises ValueError: if the values do not match the
          :ref:`specification <m4-01>`
486466
def init(self, left_end_needle, right_end_needle):
        
        if not isinstance(left_end_needle, int):

            raise TypeError(_left_end_needle_error_message(left_end_needle))
        if left_end_needle < 0 or left_end_needle > 198:
            raise ValueError(_left_end_needle_error_message(left_end_needle))
        if not isinstance(right_end_needle, int):
            raise TypeError(_right_end_needle_error_message(right_end_needle))
        if right_end_needle < 1 or right_end_needle > 199:
            raise ValueError(_right_end_needle_error_message(right_end_needle))
        self._left_end_needle = left_end_needle
        self._right_end_needle = right_end_needle
6229
def _initialiseIteration(self):
        
        self._searchIterator = self._search(
            self._request.start,
            self._request.end if self._request.end != 0 else None)
        self._currentObject = next(self._searchIterator, None)
        if self._currentObject is not None:
            self._nextObject = next(self._searchIterator, None)
            self._searchAnchor = self._request.start
            self._distanceFromAnchor = 0
            firstObjectStart = self._getStart(self._currentObject)
            if firstObjectStart > self._request.start:
                self._searchAnchor = firstObjectStart
1034124
def _run_atstart():
    ''''''
    global _atstart
    for callback, args, kwargs in _atstart:
        callback(*args, **kwargs)
    del _atstart[:]
1067033
def init(req, model):  # pylint: disable=unused-argument
    

    params = {}

    for key, val in req.params.items():
        try:
            rtype, fields = _parse_param(key, val)
            params[rtype] = fields
        except TypeError:
            continue

    if params:
        _validate_req(req)
        for rtype, fields in params.items():
            _validate_param(rtype, fields)
    return params
1489
def begin(self):
        

        resp = ws.ws2811_init(self._leds)
        if resp != 0:
            str_resp = ws.ws2811_get_return_t_str(resp)
            raise RuntimeError('ws2811_init failed with code {0} ({1})'.format(resp, str_resp))
230931
def init(base_url, username=None, password=None, verify=True):
    """"""
    handler = RequestHandler(base_url, username, password, verify)
    set_default_request_handler(handler)
    return handler
736857
def start(self):
		
		timeout = self.timeout()
		if timeout is not None and timeout > 0:
			self.__loop.add_timeout(timedelta(0, timeout), self.stop)
		self.handler().setup_handler(self.loop())
		self.loop().start()
		self.handler().loop_stopped()
636996
def start(self, *args, **kwargs):#pylint:disable=unused-argument
        
        restart = kwargs.get('restart', True)
        return self.run(restart)
193906
def start(self, *args, **kwargs):
        
        warnings.warn(
            "The 'start()' method is deprecated, please use 'add()' instead", DeprecationWarning
        )
        return self.add(*args, **kwargs)
808809
def _start_stop(item):
    
    if isinstance(item, tuple):
        item = item[0]
    if isinstance(item, slice):
        # Slice.
        if item.step not in (None, 1):
            raise NotImplementedError()
        return item.start, item.stop
    elif isinstance(item, (list, np.ndarray)):
        # List or array of indices.
        return np.min(item), np.max(item)
    else:
        # Integer.
        return item, item + 1
729824
def start(self, value: typing.Union[float, NormPointType]) -> None:
        """"""
        self.set_property("start", value)
1227432
def default_start_index(self, value):
        """"""
        if not isinstance(value, int):
            raise TypeError('default_start_index attribute must be of int '
                            'type.')
        self._default_start_index = value
266773
function begins(query, node) {
  var value = node[query.name]

  return (
    typeof value === 'string' &&
    value.slice(0, query.value.length) === query.value
  )
}
844441
def init_value(self, string_value):
        
        value = self.validate_value(string_value)
        self._value = defaultdict(lambda: value)
1135467
def threaded_start(self, no_init=False):
        '''
        
        '''
        thread = Thread(target=self.init_connections, kwargs={
                        'no_init': no_init})
        thread.setDaemon(True)
        thread.start()
        thread.join()
672319
def onStart(self, event):
        
        c = event.container
        print '+' * 5, 'started:', c
        kv = lambda s: s.split('=', 1)
        env = {k: v for (k, v) in (kv(s) for s in c.attrs['Config']['Env'])}
        print env
810401
def start(self, *args, **kwargs):
        
        self._stop = False
        super(ReadProbes, self).start(*args, **kwargs)