See :func:`send_location`
356574
def send_location(self, *args, **kwargs):
        """"""
        return send_location(*args, **self._merge_overrides(**kwargs)).run()
1168160
def send_zdistance_setpoint(self, roll, pitch, yawrate, zdistance):
        
        pk = CRTPPacket()
        pk.port = CRTPPort.COMMANDER_GENERIC
        pk.data = struct.pack('<Bffff', TYPE_ZDISTANCE,
                              roll, pitch, yawrate, zdistance)
        self._cf.send_packet(pk)
56781
def send(self, task_path, args, kwargs):
        
        message = {
                'task_path': task_path,
                'capture_response': self.capture_response,
                'response_id': self.response_id,
                'args': args,
                'kwargs': kwargs
            }
        self._send(message)
        return self
825162
def _stmt_location_to_agents(stmt, location):
    
    if location is None:
        return
    agents = stmt.agent_list()
    for a in agents:
        if a is not None:
            a.location = location
671449
def addLocation(self, locationUri, weight):
        
        assert isinstance(weight, (float, int)), "weight value has to be a positive or negative integer"
        self.topicPage["locations"].append({"uri": locationUri, "wgt": weight})
1223495
def send_location(chat_id:, latitude:, longitude:, reply_to_message_id: nil, reply_markup: nil)
      result = call(:sendLocation, chat_id: chat_id,
                                   latitude: latitude,
                                   longitude: longitude,
                                   reply_to_message_id: reply_to_message_id,
                                   reply_markup: reply_markup)
      Message.new(result)
    end
1046533
private boolean locationAwareLog(int level_int, Throwable t, String msgTemplate, Object[] arguments) {
		return locationAwareLog(FQCN, level_int, t, msgTemplate, arguments);
	}
1194442
async def sendVenue(self, chat_id, latitude, longitude, title, address,
                        foursquare_id=None,
                        foursquare_type=None,
                        disable_notification=None,
                        reply_to_message_id=None,
                        reply_markup=None):
        
        p = _strip(locals())
        return await self._api_request('sendVenue', _rectify(p))
1258582
def send_point(point)
      if opts[:noop]
        logger.log "Would send: #{point}"
        return
      end

      logger.log("Sending: #{point}", :debug)
      writer.send_point(point)
    end
1243570
private ILexLocation location(int tokline, int tokpos, int startOffset,
			int endOffset)
	{
		// Fix for location on traces
		if (this.location != null)
		{
			return this.location;
		} else
		{
			return new LexLocation(file, currentModule, tokline, tokpos, linecount, charpos, startOffset, endOffset);
		}
	}
1181019
def set_location(self, new_location):
        
        self._load_raw_content()
        self._location = new_location
        self.get_filepath(renew=True)
        return
444219
def send_request(self, target: str, *args, **kwargs):
        
        # TODO: Log error here if not found?
        address = self._get_address_from_source(target)
        if address is None:
            return

        args = json.dumps(args).encode('utf8')
        kwargs = json.dumps(kwargs).encode('utf8')

        # TODO: test that this works
        # NOTE: pop out command?
        frame = (*address, b'', b'MSG', args, kwargs)
        self.add_callback(self.command_socket.send_multipart, frame)
727508
def sendp(x, inter=0, loop=0, iface=None, iface_hint=None, count=None, verbose=None, realtime=None, *args, **kargs):
    """"""
    if iface is None and iface_hint is not None:
        iface = conf.route.route(iface_hint)[0]
    __gen_send(conf.L2socket(iface=iface, *args, **kargs), x, inter=inter, loop=loop, count=count, verbose=verbose, realtime=realtime)
1247345
def encode_location(location: BioCLocation):
    """"""
    return etree.Element('location',
                         {'offset': str(location.offset), 'length': str(location.length)})
618919
def include(self, location, namespace=None, app_name=None):
        
        sorted_entries = sorted(self.routes, key=operator.itemgetter(0),
                                reverse=True)

        arg = [u for _, u in sorted_entries]
        return url(location, urls.include(
            arg=arg,
            namespace=namespace,
            app_name=app_name))
17740
def send_dir(self, local_path, remote_path, user='root'):
        
        self.enable_user(user)
        return self.ssh_pool.send_dir(user, local_path, remote_path)
582034
async def set_position(self, position, wait_for_completion=True):
        
        command_send = CommandSend(
            pyvlx=self.pyvlx,
            wait_for_completion=wait_for_completion,
            node_id=self.node_id,
            parameter=position)
        await command_send.do_api_call()
        if not command_send.success:
            raise PyVLXException("Unable to send command")
        await self.after_update()