Sends a "play" command to the player.
776044
def pause(self):
        
        msg = cr.Message()
        msg.type = cr.PAUSE
        self.send_message(msg)
114365
def play(file_or_url, options = {})
      @players = @devices.map { |device| device.play(file_or_url, options) }
      Players.new(@players)
    end
12397
def command(cmd):
    """"""
    message = create(protobuf.SEND_COMMAND_MESSAGE)
    send_command = message.inner()
    send_command.command = cmd
    return message
713387
@Override
  public void play(SpeechAnnouncement speechAnnouncement) {
    boolean isValidAnnouncement = speechAnnouncement != null
      && !TextUtils.isEmpty(speechAnnouncement.announcement());
    boolean canPlay = isValidAnnouncement && languageSupported && !isMuted;
    if (!canPlay) {
      return;
    }

    fireInstructionListenerIfApi14();

    HashMap<String, String> params = new HashMap<>(1);
    params.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, DEFAULT_UTTERANCE_ID);
    textToSpeech.speak(speechAnnouncement.announcement(), TextToSpeech.QUEUE_ADD, params);
  }
1035202
def play(self):
        
        data, options = self.parse_request()
        #warning: 'data' are the raw data from the client, not the de-serialised ones
        outputs = self.run(data, options)
        return jsonify(outputs)
20413
def send_simple_command(self, cmd):
        """"""
        pkt = MqttPkt()
        
        pkt.command = cmd
        pkt.remaining_length = 0
        
        ret = pkt.alloc()
        if ret != NC.ERR_SUCCESS:
            return ret
        
        return self.packet_queue(pkt)
205589
def _run_player(self, extra_cmd):
        
        # Force quit old process
        if self.is_alive:
            self.quit()
        args = self._args + extra_cmd
        logger.debug("Exec: " + ' '.join(args))
        self.sub_proc = subprocess.Popen(
            args,
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=self._null_file,
            preexec_fn=os.setsid
        )
        # Set up NONBLOCKING flag for the pipe
        flags = fcntl.fcntl(self.sub_proc.stdout, fcntl.F_GETFL)
        flags |= os.O_NONBLOCK
        fcntl.fcntl(self.sub_proc.stdout, fcntl.F_SETFL, flags)
        # Start watchdog
        Thread(target=self._watchdog).start()
127498
def add_play(self, choice, count=1):
        """"""
        self.redis.hincrby(EXPERIMENT_REDIS_KEY_TEMPLATE % self.name, "%s:plays" % choice, count)
        self._choices = None
529778
function onUserPlayerChange(data){

            var player = gameData.player;

            //Check if data contains different values
            if (player.get("angle") !== data.angle.toPrecision(1) || player.get("isAccelerating") !== data.isAccelerating){
                var buffer = micro.toBinary(data, "PlayerUpdate");
                socket.send(buffer);

                //Allow for latency before setting these changes on the player
                setTimeout(function(){
                    player.set(data);
                }, latency);
            }
        }
1179987
def send_command(self, command, *arguments):
        
        self.api.send_command(self, command, *arguments)
1063102
def send_command(self, cmd, priority=False):
        
        if priority:
            self._pending.insert(0, cmd)
        else:
            self._pending.append(cmd)
        self._pending_size += len(cmd)

        if self._pending_size > DEFAULT_PENDING_SIZE:
            yield self._flush_pending()
1318131
def sendCMD (self, vel):
        '''
        

        '''
        self.lock.acquire()
        self.vel = vel
        self.lock.release()
189666
def start_ipython_player(commands, speed=1):
    """"""
    PlayerTerminalIPythonApp.commands = commands
    PlayerTerminalIPythonApp.speed = speed
    PlayerTerminalIPythonApp.launch_instance()
1106573
def onSendCommand(self):
        ''''''
        self.agent_host.sendCommand(self.command_entry.get())
        self.command_entry.delete(0,END)
        self.canvas.focus_set()
1268761
def send_command(self, data, read_delay=None):
        """"""
        self._write(data)
        if read_delay:
            time.sleep(read_delay)
        return self._read()
846711
def play(quiet, session_file, shell, speed, prompt, commentecho):
    """"""
    run(
        session_file.readlines(),
        shell=shell,
        speed=speed,
        quiet=quiet,
        test_mode=TESTING,
        prompt_template=prompt,
        commentecho=commentecho,
    )
120415
async def jsk_vc_play(self, ctx: commands.Context, *, uri: str):
        

        voice = ctx.guild.voice_client

        if voice.is_playing():
            voice.stop()

        # remove embed maskers if present
        uri = uri.lstrip("<").rstrip(">")

        voice.play(discord.PCMVolumeTransformer(discord.FFmpegPCMAudio(uri)))
        await ctx.send(f"Playing in {voice.channel.name}.")