Use this method to move a sticker in a set created by the bot to a specific position . Returns True on success.
        :param sticker:
        :param position:
        :return:
558640
def set_sticker_position_in_set(self, sticker, position):
        
        return apihelper.set_sticker_position_in_set(self.token, sticker, position)
1161087
def send_sticker(self, *args, **kwargs):
        """"""
        return send_sticker(*args, **self._merge_overrides(**kwargs)).run()
1070071
def send_sticker(self, sticker: str, reply: Message=None, on_success: callable=None,
                     reply_markup: botapi.ReplyMarkup=None):
        

        self.twx.send_sticker(peer=self, sticker=sticker, reply_to_message_id=reply, on_success=on_success,
                              reply_markup=reply_markup)
952973
def possible_moves(self, position):
        
        # Chain used to combine multiple generators
        for move in itertools.chain(*[self.add(fn, position) for fn in self.cardinal_directions]):
            yield move

        for move in self.add_castle(position):
            yield move
986382
private void moveTo(int posX, int posY) {

        posX = (posX < 0)
        ? 0
        : (((posX + m_currentSelection.getWidth()) >= m_elementWidth)
        ? m_elementWidth - m_currentSelection.getWidth()
        : posX);
        posY = (posY < 0)
        ? 0
        : (((posY + m_currentSelection.getHeight()) >= m_elementHeight)
        ? m_elementHeight - m_currentSelection.getHeight()
        : posY);

        m_markerStyle.setTop(posY, Unit.PX);
        m_markerStyle.setLeft(posX, Unit.PX);

        m_overlayLeftStyle.setWidth(posX, Unit.PX);

        m_overlayTopStyle.setLeft(posX, Unit.PX);
        m_overlayTopStyle.setHeight(posY, Unit.PX);

        m_overlayBottomStyle.setLeft(posX, Unit.PX);
        m_overlayBottomStyle.setHeight(m_elementHeight - posY - m_currentSelection.getHeight(), Unit.PX);

        m_overlayRightStyle.setWidth(m_elementWidth - posX - m_currentSelection.getWidth(), Unit.PX);

        m_currentSelection.setTop(posY);
        m_currentSelection.setLeft(posX);
    }
1001178
def move_todo_item(self, item_id, to):
        
        path = '/todos/move_item/%u' % item_id
        req = ET.Element('request')
        ET.SubElement(req, 'to').text = str(int(to))
        return self._request(path, req)
312840
def __move(self, current_pos):
        '''
        
        '''
        if self.__move_range is not None:
            next_pos = np.random.randint(current_pos - self.__move_range, current_pos + self.__move_range)
            if next_pos < 0:
                next_pos = 0
            elif next_pos >= self.var_arr.shape[0] - 1:
                next_pos = self.var_arr.shape[0] - 1
            return next_pos
        else:
            next_pos = np.random.randint(self.var_arr.shape[0] - 1)
            return next_pos
1189268
async def sendSticker(self, chat_id, sticker,
                          disable_notification=None,
                          reply_to_message_id=None,
                          reply_markup=None):
        
        p = _strip(locals(), more=['sticker'])
        return await self._api_request_with_file('sendSticker', _rectify(p), 'sticker', sticker)
136061
def accel_move_tab_right(self, *args):
        # TODO KEYBINDINGS ONLY
        
        pos = self.get_notebook().get_current_page()
        if pos != self.get_notebook().get_n_pages() - 1:
            self.move_tab(pos, pos + 1)
        return True
368101
def move_to(self, target, position='first-child'):
        """"""

        # Invalidate both in case position matters,
        # otherwise only target is needed.
        self.invalidate()
        target.invalidate()
        super(Page, self).move_to(target, position=position)
258285
def go_to_position(self, position):
        

        cursor = self.textCursor()
        cursor.setPosition(position)
        self.setTextCursor(cursor)
        return True
1040300
def add(self, func, position):
        
        try:
            if self.loc_adjacent_to_opponent_king(func(self.location), position):
                return
        except IndexError:
            return

        if position.is_square_empty(func(self.location)):
            yield self.create_move(func(self.location), notation_const.MOVEMENT)

        elif position.piece_at_square(func(self.location)).color != self.color:
            yield self.create_move(func(self.location), notation_const.CAPTURE)
484459
def set_cursor_position(self, path, position):
        
        try:
            map = json.loads(self._settings.value('cachedCursorPosition'))
        except TypeError:
            map = {}
        map[path] = position
        self._settings.setValue('cachedCursorPosition', json.dumps(map))
6926
def move(self, x, y):
        
        if self.brush_on:
            for lx, ly in line(self.pos_x, self.pos_y, x, y):
                self.set(lx, ly)

        self.pos_x = x
        self.pos_y = y
1003381
def setposition(self, moves=[]):
        
        self.put('position startpos moves %s' % Engine._movelisttostr(moves))
        self.isready()
688498
async def move_camera(self, position: Union[Unit, Point2, Point3]):
        
        assert isinstance(position, (Unit, Point2, Point3))
        if isinstance(position, Unit):
            position = position.position
        await self._execute(
            action=sc_pb.RequestAction(
                actions=[
                    sc_pb.Action(
                        action_raw=raw_pb.ActionRaw(
                            camera_move=raw_pb.ActionRawCameraMove(
                                center_world_space=common_pb.Point(x=position.x, y=position.y)
                            )
                        )
                    )
                ]
            )
        )
578520
def move_by_offset(self, xoffset, yoffset):
        
        if self._driver.w3c:
            self.w3c_actions.pointer_action.move_by(xoffset, yoffset)
            self.w3c_actions.key_action.pause()
        else:
            self._actions.append(lambda: self._driver.execute(
                Command.MOVE_TO, {
                    'xoffset': int(xoffset),
                    'yoffset': int(yoffset)}))
        return self