Python MPDClient.timeout方法代码示例

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
def mpd_status():
    client = MPDClient()
    client.timeout = 10
    client.idletimeout = None
    client.connect("lounge.mpd.shack", 6600)
    answer = client.currentsong()
    state = client.status()
    client.close()
    client.disconnect()
    if 'artist' in answer:
        return jsonify(artist = answer['artist'],
                   title = answer['title'],
                   status = state['state'],
                   stream = 'false')
    elif 'name' in answer:
        return jsonify(name=answer['name'],
                       title=answer['title'],
                       stream='true',
                       status = state['state'])
    elif 'file' in answer:
        return jsonify(title=answer['file'],
                       status = state['state'],
                       stream='undef')
    else:
        return jsonify(error='unknown playback type')
    return jsonify(error='unknown playback type')

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
def print_files():
    sync_files = open('/media/satellite_mpds/files2sync.txt','a')
    client=MPDClient()
    mopidyAddress = 'localhost'
    mopidyPort = 6600

    client.timeout = 10
    client.idletimeout = None
    client.connect(mopidyAddress,mopidyPort)
    #client.password('IlPits2013')
    files = client.playlistinfo()
#    files = client.lsinfo(foldername)
    files = [x['file'] for x in files]
    files = sorted(files)
    outfiles=[]
    for f in files:
        real_path=os.path.join(music_dir,f)
        if os.path.exists(real_path):
            if os.path.islink(real_path):
                target_path = os.readlink(real_path)
                abs_target_path = os.path.realpath(real_path)
                target_path_rel_to_music_dir = os.path.relpath(abs_target_path, music_dir)
                print target_path_rel_to_music_dir
                sync_files.write(target_path_rel_to_music_dir+'\n')
                outfiles.append(target_path_rel_to_music_dir)
            sync_files.write(f+'\n')
            outfiles.append(f)
            print('ADDED')
            print f
    sync_files.close()
    #print(files)
    client.disconnect()

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
    def delegateInput(self, texts):
        """A wrapper for querying brain."""

        # check if input is meant to start the music module
        for text in texts:
            if any(x in text.upper() for x in ["SPOTIFY", "MUSIC"]):
                self._logger.debug("Preparing to start music module")
                # check if mpd client is running
                try:
                    client = MPDClient()
                    client.timeout = None
                    client.idletimeout = None
                    client.connect("localhost", 6600)
                except:
                    self._logger.critical("Can't connect to mpd client, cannot start music mode.", exc_info=True)
                    self.mic.say(
                        "I'm sorry. It seems that Spotify is not enabled. Please read the documentation to learn how to configure Spotify.")
                    return

                self.mic.say("Please give me a moment, I'm loading your Spotify playlists.")
                self._logger.debug("Starting music mode")
                music_mode = MusicMode(self.persona, self.mic)
                music_mode.handleForever()
                self._logger.debug("Exiting music mode")
                return

        self.brain.query(texts)

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
def play_playlist(name):
    client=MPDClient()
    mopidyAddress = 'localhost'
    mopidyPort = 6600

    client.timeout = 10
    client.idletimeout = None
    client.connect(mopidyAddress,mopidyPort)
    #client.password('IlPits2013')
    client.clear()
    if playlist_exists(name):
        client.load(name)
    spotify_lists = get_spotify_playlists()
    name = name.encode('utf-8')
    print name
    #print spotify_lists
    if name in spotify_lists:
        add_spotify_directory(name)
    #time.sleep(1)
    if name == 'Pierre':
        client.shuffle()

    #client.setvol(50)
    #client.play()
    client.disconnect()
    return

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
 def delegateInput(self, text):
     """A wrapper for querying brain."""
     got_hit = False
     # check if input is meant to start the music module
     if any(x in text.upper() for x in ["SPOTIFY", "MUSIC"]):
         # check if mpd client is running
         try:
             client = MPDClient()
             client.timeout = None
             client.idletimeout = None
             client.connect("localhost", 6600)
         except:
             self.logger.warning("Failed to init MPDClient")
             self.mic.say("Wybacz, ale najwyraźniej usługa Spotify nie działa")
             return
         
         self.logger.info("waiting for Spotify playlist")
         self.mic.say("Poczekaj chwilę, wczytuję listę utworów Spotify")
         music_mode = MusicMode(self.persona, self.mic, self.logger)
         music_mode.handleForever()
         return
     else:
       if " następnie " in lowerUTF8(text):
         l_text = text.split(" następnie ")
         for text in l_text:
           new_got_hit = self.brain.query(text)
           got_hit = got_hit or new_got_hit
       else:
         got_hit = self.brain.query(text)
     return got_hit

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
	def connect(self,port):
		global client
		connection = False
		retry = 2
		while retry > 0:
			client = MPDClient()	# Create the MPD client
			try:
				client.timeout = 10
				client.idletimeout = None
				client.connect("localhost", port)
				log.message("Connected to MPD port " + str(port), log.INFO)
				connection = True
				retry = 0
			except:
				log.message("Failed to connect to MPD on port " + str(port), log.ERROR)
				time.sleep(0.5)	# Wait for interrupt in the case of a shutdown
				log.message("Restarting MPD",log.DEBUG)
				if retry < 2:
					self.execCommand("service mpd restart") 
				else:
					self.execCommand("service mpd start") 
				time.sleep(2)	# Give MPD time to restart
				retry -= 1

		return connection

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
 def __enter__(self):
     client = MPDClient(use_unicode=True)
     self.client = client
     client.timeout = 1
     client.idletimeout = None
     client.connect("131.urlab.be", 6600)
     return client

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
 def play_id(play_id):
     client = MPDClient()
     client.connect(app.config['MPD']['host'], app.config['MPD']['port'])
     client.timeout = None
     client.idletimeout = None
     client.playid(play_id)
     return redirect(url_for('player'))

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
def yoinkMPD(cod):
    mpd = MPDClient(use_unicode=True)
    mpd.timeout = None
    mpd.idletimeout = None
    mpd.connect(cod.config["mpd"]["host"], cod.config["mpd"]["port"])

    return mpd

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
    def excuteCommand(con, channel, user, message, isMod, isSub):
	    client = MPDClient()
	    client.timeout = 10
	    client.idletimeout = None
	    client.connect("bluesnogbox.duckdns.org", 6600)
	    send_message(con, channel, 'mpd version: ' + client.mpd_version)
	    client.close()
	    client.disconnect()

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
def get_mpd_string():
    '''
        gets the current song using MPDClient library
        https://github.com/Mic92/python-mpd2
        $ pip install python-mpd2
    '''
    c = MPDClient()
    c.timeout = 2
    try:
        c.connect('localhost', 6600)
    except:
        return None

    status = c.status()

    if status['state'] != 'play':
        return None

    metalist = []
    song = c.currentsong()

    artist = song.get('artist', None)
    if isinstance(artist, list):
    	artist = ' ／ '.join(artist)

    title = song.get('title', None)
    if isinstance(title, list):
    	title = ' ／ '.join(title)

    if artist is None and title is None:
        filename = song.get('file', None)
        if filename is not None:
            filename = filename
            filename = os.path.basename(filename).replace('_', ' ')
            filename, _, ext = filename.rpartition('.')
            if filename == '':
                filename = ext
            metalist.append(filename)
    else:
        if artist is not None:
            metalist.append(artist)
        if title is not None:
            metalist.append(title)

    if len(metalist) == 0:
        hexchat.prnt('Metadata not found.')
        return None

    metastr = ' - '.join(metalist)

    seconds = int(song.get('time', None))
    minutes = seconds // 60
    seconds = seconds % 60

    d = {'meta': metastr, 'sec': seconds, 'min': minutes}
    metastr = '{meta} - {min}:{sec:02d}'.format(**d)

    return metastr

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
def item_chosen(button, choice):

    client = MPDClient()               # create client object
    client.timeout = 10                # network timeout in seconds (floats allowed), default: None
    client.idletimeout = None          # timeout for fetching the result of the idle command is handled seperately, default: None
    host = os.environ.get('MPD_HOST','localhost')
    client.connect(host, 6600)  # connect to localhost:6600

    client.add(choice)

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
def mpdInit():
    global client
    client = MPDClient()                        
    client.timeout = 10                          
    client.idletimeout = None                   
    client.connect("localhost", 6600)   
    client.password("1234")
    client.setvol(20)
    return client

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
def startClient():
    client = MPDClient()               # create client object
    # network timeout in seconds (floats allowed), default: None
    client.timeout = 10
    # timeout for fetching the result of the idle command is handled
    # seperately, default: None
    client.idletimeout = None
    client.connect("localhost", 6600)  # connect to localhost:6600
    return client

# 需要导入模块: from mpd import MPDClient [as 别名]
# 或者: from mpd.MPDClient import timeout [as 别名]
    def __init__(self):
        
        # conenct client and set values
        client = MPDClient()
        client.timeout = 30
        client.idletimeout = None
        client.connect("localhost", 6600)
	print(client.status())
        self.client = client