コード例 #1
0
ファイル: nicotine.py プロジェクト: swak/nicotine-plus
def renameprocess(newname, debug=False):
    errors = []
    # Renaming ourselves for ps et al.
    try:
        import procname

        procname.setprocname(newname)
    except:
        errors.append("Failed procname module")
        # Renaming ourselves for pkill et al.
    try:
        import ctypes

        # Linux style
        libc = ctypes.CDLL("libc.so.6")
        libc.prctl(15, newname, 0, 0, 0)
    except:
        errors.append("Failed linux style")
    try:
        import dl

        # FreeBSD style
        libc = dl.open("/lib/libc.so.6")
        libc.call("setproctitle", newname + "\0")
        renamed = True
    except:
        errors.append("Failed FreeBSD style")
    if debug and errors:
        msg = [_("Errors occured while trying to change process name:")]
        for i in errors:
            msg.append("%s" % (i,))
        log.addwarning("\n".join(msg))
コード例 #2
0
    def foobar(self):
        """ Function to get foobar currently playing song on windows """

        if sys.platform == "win32":
            try:
                from win32gui import GetWindowText, FindWindow
            except ImportError as error:
                log.addwarning(_("ERROR: foobar: failed to load win32gui module: %(error)s") % {"error": error})
                return None
        else:
            log.addwarning(_("ERROR: foobar: is only supported on windows."))
            return None

        wnd_ids = [
            '{DA7CD0DE-1602-45e6-89A1-C2CA151E008E}',
            '{97E27FAA-C0B3-4b8e-A693-ED7881E99FC1}',
            '{E7076D1C-A7BF-4f39-B771-BCBE88F2A2A8}'
        ]

        metadata = None

        for wnd_id in wnd_ids:
            wnd_txt = GetWindowText(FindWindow(wnd_id, None))
            if wnd_txt:
                m = re.match("(.*)\s+\[foobar.*", wnd_txt)
                if m:
                    metadata = m.groups(0)[0].strip()

        if metadata:
            self.title["nowplaying"] = "now playing: " + metadata.decode('mbcs')
            return True
        else:
            return None
コード例 #3
0
    def amarok(self):
        """ Function to get amarok currently playing song """

        try:
            import dbus
            import dbus.glib
        except ImportError as error:
            log.addwarning(_("ERROR: amarok: failed to load dbus module: %(error)s") % {"error": error})
            return None

        self.bus = dbus.SessionBus()

        player = self.bus.get_object('org.mpris.amarok', '/Player')
        md = player.GetMetadata()

        for key, value in md.iteritems():

            if key == 'mtime':
                # Convert seconds to minutes:seconds
                value = float(value) / 1000
                m, s = divmod(value, 60)
                self.title['length'] = "%d:%02d" % (m, s)
            elif key == 'audio-bitrate':
                self.title['bitrate'] = value
            elif key == "location":
                self.title['filename']
            else:
                self.title[key] = value

            self.title['nowplaying'] = self.title['artist'] + ' - ' + self.title['title']

        return True
コード例 #4
0
ファイル: nowplaying.py プロジェクト: seeschloss/nicotine
	def amarok2(self):
		if not self.bus:
			log.addwarning("Failed to import DBus, cannot read out Amarok2")
			return
		player = self.bus.Interface(bus.get_object('org.mpris.amarok', '/Player'), dbus_interface='org.freedesktop.MediaPlayer')
		md = player.GetMetadata()
		for key, value in md.iteritems():
			self.title[key] = unicode(value, 'iso8859-15', 'replace')
		return True
コード例 #5
0
    def other(self):
        try:
            othercommand = self.NPCommand.get_text()
            if othercommand == "":
                return None

            output = executeCommand(othercommand, returnoutput=True)
            self.title["nowplaying"] = output
            return True
        except Exception, error:
            log.addwarning(_("ERROR: Executing '%(command)s' failed: %(error)s") % {"command": othercommand, "error": error})
            return None
コード例 #6
0
    def mpris(self):
        """ Function to get the currently playing song via dbus mpris v2 interface """

        # https://media.readthedocs.org/pdf/mpris2/latest/mpris2.pdf
        try:
            import dbus
            import dbus.glib
        except ImportError as error:
            log.addwarning(_("ERROR: MPRIS: failed to load dbus module: %(error)s") % {"error": error})
            return None

        self.bus = dbus.SessionBus()

        player = self.NPCommand.get_text()

        dbus_mpris_service = u'org.mpris.MediaPlayer2.'
        dbus_mpris_player_service = u'org.mpris.MediaPlayer2.Player'
        dbus_mpris_path = u'/org/mpris/MediaPlayer2'
        dbus_property = u'org.freedesktop.DBus.Properties'

        if not player:

            names = self.bus.list_names()
            players = []

            for name in names:
                if name.startswith(dbus_mpris_service):
                    players.append(name[len(dbus_mpris_service):])

            if not players:
                log.addwarning(_("ERROR: MPRIS: Could not find a suitable MPRIS player."))
                return None

            player = players[0]
            if len(players) > 1:
                log.addwarning(_("Found multiple MPRIS players: %(players)s. Using: %(player)s") % {'players': players, 'player': player})
            else:
                log.addwarning(_("Auto-detected MPRIS player: %s.") % player)

        try:
            player_obj = self.bus.get_object(dbus_mpris_service + player, dbus_mpris_path)
            player_property_obj = dbus.Interface(player_obj, dbus_interface=dbus_property)
            metadata = player_property_obj.Get(dbus_mpris_player_service, "Metadata")
        except Exception, exception:
            log.addwarning(_("ERROR: MPRIS: Something went wrong while querying %(player)s: %(exception)s") % {'player': player, 'exception': exception})
            return None
コード例 #7
0
ファイル: search.py プロジェクト: Steeler77/nicotine-plus
	def OnAutoSearch(self, *args):
		# Wishlists supported by server?
		if self.interval == 0:
			log.addwarning("The server forbid us from doing wishlist searches.")
			return False
		
		searches = self.frame.np.config.sections["server"]["autosearch"]
		if not searches:
			return True
		
		# Search for a maximum of 3 items at each search interval
		for term in searches[0:3]:
			for i in self.searches.values():
				if i[1] == term and i[4]:
					self.DoWishListSearch(i[0], term)
					oldsearch = searches.pop()
					searches.insert(0, oldsearch)
		return True
コード例 #8
0
ファイル: shares.py プロジェクト: pepe1977/nicotine-plus
    def compress_shares(self, sharestype):

        if sharestype == "normal":
            streams = self.config.sections["transfers"]["sharedfilesstreams"]
        elif sharestype == "buddy":
            streams = self.config.sections["transfers"]["bsharedfilesstreams"]

        if streams is None:
            log.addwarning(
                _("ERROR: No %(type)s shares database available") %
                {"type": sharestype})
            return

        m = slskmessages.SharedFileList(None, streams)
        _thread.start_new_thread(m.makeNetworkMessage, (0, True))

        if sharestype == "normal":
            self.CompressedSharesNormal = m
        elif sharestype == "buddy":
            self.CompressedSharesBuddy = m
コード例 #9
0
    def CreateMenu(self):
        try:
            self.tray_popup_menu_server = popup0 = PopupMenu(self, False)
            popup0.setup(("#" + _("Connect"), self.frame.OnConnect),
                         ("#" + _("Disconnect"), self.frame.OnDisconnect))

            self.tray_popup_menu = popup = PopupMenu(self, False)
            popup.setup(
                ("#" + _("Hide / Show Nicotine+"), self.HideUnhideWindow),
                (1, _("Server"), self.tray_popup_menu_server,
                 self.OnPopupServer),
                ("#" + _("Settings"), self.frame.OnSettings),
                ("#" + _("Send Message"), self.OnOpenPrivateChat),
                ("#" + _("Lookup a User's IP"), self.OnGetAUsersIP),
                ("#" + _("Lookup a User's Info"), self.OnGetAUsersInfo),
                ("#" + _("Lookup a User's Shares"), self.OnGetAUsersShares),
                ("$" + _("Toggle Away"), self.frame.OnAway),
                ("#" + _("Quit"), self.frame.OnExit))
        except Exception as e:
            log.addwarning(_('ERROR: tray menu, %(error)s') % {'error': e})
コード例 #10
0
ファイル: config.py プロジェクト: zniavre/nicotine-plus
    def writeAliases(self):

        try:
            f = open(self.filename + ".alias", "wb")
        except Exception as e:
            log.addwarning(
                _("Something went wrong while opening your alias file: %s") %
                e)
        else:
            try:
                pickle.dump(self.aliases, f, protocol=pickle.HIGHEST_PROTOCOL)
                f.close()
            except Exception as e:
                log.addwarning(
                    _("Something went wrong while saving your alias file: %s")
                    % e)
        finally:
            try:
                f.close()
            except Exception:
                pass
コード例 #11
0
	def amarok2(self):
		slist = self.NPFormat.child.get_text()
		if not self.bus:
			log.addwarning("Failed to import DBus, cannot read out Amarok2")
			return
		player = self.bus.get_object('org.mpris.amarok', '/Player')
		md = player.GetMetadata()
		for key, value in md.iteritems():
			if key == 'mtime':
				# Convert seconds to minutes:seconds
				value = float(value) / 1000
				m, s = divmod(value, 60)
				self.title['length'] = "%d:%02d" % (m, s)
			elif key == 'audio-bitrate':
				self.title['bitrate'] = value
			elif key == "location":
				self.title['filename']
			else:
				self.title[key] = value
			self.title['nowplaying'] = self.title['artist']+' - '+self.title['title']
		return True
コード例 #12
0
    def lastfm(self):
        """ Function to get the last song played via lastfm api """

        import httplib
        import json

        try:
            conn = httplib.HTTPConnection("ws.audioscrobbler.com")
        except Exception as error:
            log.addwarning(_("ERROR: lastfm: Could not connect to audioscrobbler: %(error)s") % {"error": error})
            return None

        try:
            (user, apikey) = self.NPCommand.get_text().split(';')
        except ValueError as error:
            log.addwarning(_("ERROR: lastfm: Please provide both your lastfm username and API key"))
            return None

        conn.request("GET", "/2.0/?method=user.getrecenttracks&user="******"&api_key=" + apikey + "&format=json")
        resp = conn.getresponse()
        data = resp.read()

        if resp.status != 200 or resp.reason != "OK":
            log.addwarning(_("ERROR: lastfm: Could not get recent track from audioscrobbler: %(error)s") % {"error": str(data)})
            return None

        json_api = json.loads(data)
        lastplayed = json_api["recenttracks"]["track"][0]

        self.title["artist"] = lastplayed["artist"]["#text"]
        self.title["title"] = lastplayed["name"]
        self.title["album"] = lastplayed["album"]["#text"]
        self.title["nowplaying"] = "%s: %s - %s - %s" % (_("Last played"), self.title["artist"], self.title["album"], self.title["title"])

        return True
コード例 #13
0
ファイル: tray.py プロジェクト: zniavre/nicotine-plus
    def SetImage(self, status=None):
        if not self.IsTrayIconVisible():
            return

        try:
            if status is not None:
                self.tray_status["status"] = status

            # Check for hilites, and display hilite icon if there is a room or private hilite
            if self.frame.hilites["rooms"] == [] and self.frame.hilites[
                    "private"] == []:
                # If there is no hilite, display the status
                icon_name = self.tray_status["status"]
            else:
                icon_name = "msg"

            if icon_name != self.tray_status["last"]:
                self.tray_status["last"] = icon_name

            if self.appindicator is not None:
                if self.custom_icons:
                    icon_name = "trayicon_" + icon_name
                else:
                    icon_name = "org.nicotine_plus.Nicotine-" + icon_name

                self.trayicon.set_icon_full(icon_name, "Nicotine+")

            else:
                # GtkStatusIcon fallback
                if self.custom_icons or self.local_icons:
                    self.trayicon.set_from_pixbuf(
                        self.frame.images["trayicon_" + icon_name])
                else:
                    self.trayicon.set_from_icon_name(
                        "org.nicotine_plus.Nicotine-" + icon_name)

        except Exception as e:
            log.addwarning(
                _("ERROR: cannot set trayicon image: %(error)s") %
                {'error': e})
コード例 #14
0
ファイル: shares.py プロジェクト: zniavre/nicotine-plus
    def getDirStream(self, dir):

        message = slskmessages.SlskMessage()
        stream = bytearray()
        stream.extend(message.packObject(len(dir)))

        for fileinfo in dir:
            stream.extend(bytes([1]))
            stream.extend(message.packObject(fileinfo[0]))
            stream.extend(
                message.packObject(fileinfo[1], unsignedlonglong=True))

            if fileinfo[2] is not None:
                try:
                    stream.extend(message.packObject('mp3'))
                    stream.extend(message.packObject(3))

                    stream.extend(message.packObject(0))
                    stream.extend(message.packObject(fileinfo[2][0]))
                    stream.extend(message.packObject(1))
                    stream.extend(message.packObject(fileinfo[3]))
                    stream.extend(message.packObject(2))
                    stream.extend(message.packObject(fileinfo[2][1]))
                except Exception:
                    log.addwarning(
                        _(
                            "Found meta data that couldn't be encoded, possible corrupt file: '%(file)s' has a bitrate of %(bitrate)s kbs, a length of %(length)s seconds and a VBR of %(vbr)s"
                            % {
                                'file': fileinfo[0],
                                'bitrate': fileinfo[2][0],
                                'length': fileinfo[3],
                                'vbr': fileinfo[2][1]
                            }))
                    stream.extend(message.packObject(''))
                    stream.extend(message.packObject(0))
            else:
                stream.extend(message.packObject(''))
                stream.extend(message.packObject(0))

        return stream
コード例 #15
0
def detect(path):

    try:
        audio = mutagen.File(path)
    except IOError:
        return None
    except Exception as e:
        log.addwarning("Mutagen crashed on '%s': %s" % (path, e))
        return None

    try:
        audio.info
    except Exception:
        # mutagen didn't think the file was audio
        return None

    if type(audio.info) == MPEGInfo:
        return processMPEG(audio)
    elif type(audio.info) == StreamInfo:
        return processFlac(audio)
    elif type(audio.info) == OggVorbisInfo:
        return processVorbis(audio)
    elif type(audio.info) == MusepackInfo:
        return processMusepack(audio)
    elif type(audio.info) == MonkeysAudioInfo:
        return processMonkeys(audio)
    elif type(audio.info) == MP4Info:
        return processMP4(audio)
    elif type(audio.info) == ASFInfo:
        return processASF(audio)
    elif type(audio.info) == OggOpusInfo:
        return processOpus(audio)
    else:
        print("EEK, what should I do with %(type)s (%(file)s)?" % {
            "type": str(type(audio.info)),
            "file": path
        })

    return processGeneric(audio)
コード例 #16
0
ファイル: pluginsystem.py プロジェクト: zniavre/nicotine-plus
    def enable_plugin(self, pluginname):
        if pluginname in self.enabled_plugins:
            return

        try:
            plugin = self.load_plugin(pluginname)

            if not plugin:
                raise Exception("Error loading plugin '%s'" % pluginname)

            plugin.enable(self)
            self.enabled_plugins[pluginname] = plugin
            log.add(_("Enabled plugin %s") % plugin.PLUGIN.__name__)

        except Exception:
            from traceback import print_exc
            print_exc()
            log.addwarning(_("Unable to enable plugin %s") % pluginname)
            # common.log_exception(logger)
            return False

        return True
コード例 #17
0
 def writeDownloadQueue(self):
     self.config_lock.acquire()
     realfile = os.path.join(self.data_dir, 'transfers.pickle')
     tmpfile = realfile + '.tmp'
     backupfile = realfile + ' .backup'
     try:
         handle = open(tmpfile, 'wb')
     except Exception as inst:
         log.addwarning(
             _("Something went wrong while opening your transfer list: %(error)s"
               ) % {'error': str(inst)})
     else:
         try:
             pickle.dump(self.sections['transfers']['downloads'],
                         handle,
                         protocol=pickle.HIGHEST_PROTOCOL)
             handle.close()
             try:
                 # Please let it be atomic...
                 os.rename(tmpfile, realfile)
             except Exception:
                 # ...ugh. Okay, how about...
                 try:
                     os.unlink(backupfile)
                 except Exception:
                     pass
                 os.rename(realfile, backupfile)
                 os.rename(tmpfile, realfile)
         except Exception as inst:
             log.addwarning(
                 _("Something went wrong while writing your transfer list: %(error)s"
                   ) % {'error': str(inst)})
     finally:
         try:
             handle.close()
         except Exception:
             pass
     self.config_lock.release()
コード例 #18
0
ファイル: shares.py プロジェクト: pepe1977/nicotine-plus
    def load_shares(self, dbs):
        opened_shelves = []
        errors = []

        for shelvefile in dbs:
            try:
                opened_shelves.append(
                    shelve.open(shelvefile, protocol=pickle.HIGHEST_PROTOCOL))
            except Exception:
                errors.append(shelvefile)
                try:
                    os.unlink(shelvefile)
                    opened_shelves.append(
                        shelve.open(shelvefile,
                                    flag='n',
                                    protocol=pickle.HIGHEST_PROTOCOL))
                except Exception as ex:
                    log.addwarning(
                        ("Failed to unlink %s: %s" % (shelvefile, ex)))

        self.config.sections["transfers"]["sharedfiles"] = opened_shelves.pop(
            0)
        self.config.sections["transfers"]["bsharedfiles"] = opened_shelves.pop(
            0)
        self.config.sections["transfers"][
            "sharedfilesstreams"] = opened_shelves.pop(0)
        self.config.sections["transfers"][
            "bsharedfilesstreams"] = opened_shelves.pop(0)
        self.config.sections["transfers"]["wordindex"] = opened_shelves.pop(0)
        self.config.sections["transfers"]["bwordindex"] = opened_shelves.pop(0)
        self.config.sections["transfers"]["fileindex"] = opened_shelves.pop(0)
        self.config.sections["transfers"]["bfileindex"] = opened_shelves.pop(0)
        self.config.sections["transfers"]["sharedmtimes"] = opened_shelves.pop(
            0)
        self.config.sections["transfers"][
            "bsharedmtimes"] = opened_shelves.pop(0)

        if errors:
            log.addwarning(
                _("Failed to process the following databases: %(names)s") %
                {'names': '\n'.join(errors)})

            self.set_shares(sharestype="normal",
                            files={},
                            streams={},
                            mtimes={},
                            wordindex={},
                            fileindex={})
            self.set_shares(sharestype="buddy",
                            files={},
                            streams={},
                            mtimes={},
                            wordindex={},
                            fileindex={})

            log.addwarning(
                _("Shared files database seems to be corrupted, rescan your shares"
                  ))
コード例 #19
0
    def OnAutoSearch(self, *args):

        # Wishlists supported by server?
        if self.interval == 0:
            log.addwarning(
                _("The server forbid us from doing wishlist searches."))
            return False

        searches = self.frame.np.config.sections["server"]["autosearch"]

        if not searches:
            return True

        # Search for a maximum of 1 item at each search interval
        term = searches.pop()
        searches.insert(0, term)

        for i in self.searches.searches.values():
            if i[1] == term and i[4]:
                self.do_wishlist_search(i[0], term)
                break

        return True
コード例 #20
0
ファイル: shares.py プロジェクト: lene/nicotine-plus
    def RescanShares(self, msg, rebuild=False):

        try:
            files, streams, wordindex, fileindex, mtimes = self.rescandirs(
                msg.shared,
                self.config.sections["transfers"]["sharedmtimes"],
                self.config.sections["transfers"]["sharedfiles"],
                self.config.sections["transfers"]["sharedfilesstreams"],
                msg.yieldfunction,
                self.np.frame.SharesProgress,
                name=_("Shares"),
                rebuild=rebuild)

            time.sleep(0.5)

            self.np.frame.RescanFinished(
                [files, streams, wordindex, fileindex, mtimes], "normal")
        except Exception as ex:
            config_dir, data_dir = GetUserDirectories()
            log.addwarning(
                _("Failed to rebuild share, serious error occurred. If this problem persists delete %s/*.db and try again. If that doesn't help please file a bug report with the stack trace included (see terminal output after this message). Technical details: %s"
                  ) % (data_dir, ex))
            raise
コード例 #21
0
ファイル: shares.py プロジェクト: pepe1977/nicotine-plus
    def set_shares(self,
                   sharestype="normal",
                   files=None,
                   streams=None,
                   mtimes=None,
                   wordindex=None,
                   fileindex=None):

        if sharestype == "normal":
            storable_objects = [(files, "sharedfiles", "files.db"),
                                (streams, "sharedfilesstreams", "streams.db"),
                                (mtimes, "sharedmtimes", "mtimes.db"),
                                (wordindex, "wordindex", "wordindex.db"),
                                (fileindex, "fileindex", "fileindex.db")]
        else:
            storable_objects = [(files, "bsharedfiles", "buddyfiles.db"),
                                (streams, "bsharedfilesstreams",
                                 "buddystreams.db"),
                                (mtimes, "bsharedmtimes", "buddymtimes.db"),
                                (wordindex, "bwordindex", "buddywordindex.db"),
                                (fileindex, "bfileindex", "buddyfileindex.db")]

        for source, destination, filename in storable_objects:
            if source is not None:
                try:
                    self.config.sections["transfers"][destination].close()
                    self.config.sections["transfers"][
                        destination] = shelve.open(
                            os.path.join(self.config.data_dir, filename),
                            flag='n',
                            protocol=pickle.HIGHEST_PROTOCOL)
                    self.config.sections["transfers"][destination].update(
                        source)

                except Exception as e:
                    log.addwarning(_("Can't save %s: %s") % (filename, e))
                    return
コード例 #22
0
ファイル: nowplaying.py プロジェクト: emilazy/nicotine-plus
    def foobar(self):
        """ Function to get foobar currently playing song on windows """

        if sys.platform == "win32":
            try:
                from win32gui import GetWindowText, FindWindow
            except ImportError as error:
                log.addwarning(
                    _("ERROR: foobar: failed to load win32gui module: %(error)s"
                      ) % {"error": error})
                return None
        else:
            log.addwarning(_("ERROR: foobar: is only supported on windows."))
            return None

        wnd_ids = [
            '{DA7CD0DE-1602-45e6-89A1-C2CA151E008E}',
            '{97E27FAA-C0B3-4b8e-A693-ED7881E99FC1}',
            '{E7076D1C-A7BF-4f39-B771-BCBE88F2A2A8}'
        ]

        metadata = None

        for wnd_id in wnd_ids:
            wnd_txt = GetWindowText(FindWindow(wnd_id, None))
            if wnd_txt:
                m = re.match(r"(.*)\\s+\[foobar.*", wnd_txt)
                if m:
                    metadata = m.groups()[0].strip()

        if metadata:
            self.title["nowplaying"] = "now playing: " + metadata.decode(
                'mbcs')
            return True
        else:
            return None
コード例 #23
0
    def getByteStream(self, fileinfo):

        message = slskmessages.SlskMessage()

        stream = bytearray()
        stream.extend(
            bytes([1]) + message.packObject(fileinfo[0]) +
            message.packObject(NetworkLongLongType(fileinfo[1])))
        if fileinfo[2] is not None:
            try:
                msgbytes = bytearray()
                msgbytes.extend(
                    message.packObject('mp3') + message.packObject(3))
                msgbytes.extend(
                    message.packObject(0) +
                    message.packObject(NetworkIntType(fileinfo[2][0])) +
                    message.packObject(1) +
                    message.packObject(NetworkIntType(fileinfo[3])) +
                    message.packObject(2) +
                    message.packObject(NetworkIntType(fileinfo[2][1])))
                stream.extend(msgbytes)
            except Exception:
                log.addwarning(
                    _(
                        "Found meta data that couldn't be encoded, possible corrupt file: '%(file)s' has a bitrate of %(bitrate)s kbs, a length of %(length)s seconds and a VBR of %(vbr)s"
                        % {
                            'file': fileinfo[0],
                            'bitrate': fileinfo[2][0],
                            'length': fileinfo[3],
                            'vbr': fileinfo[2][1]
                        }))
                stream.extend(message.packObject('') + message.packObject(0))
        else:
            stream.extend(message.packObject('') + message.packObject(0))

        return stream
コード例 #24
0
    def lastfm(self):
        """ Function to get the last song played via lastfm api """

        import http.client
        import json

        try:
            conn = http.client.HTTPSConnection("ws.audioscrobbler.com")
        except Exception as error:
            log.addwarning(
                _("ERROR: lastfm: Could not connect to audioscrobbler: %(error)s"
                  ) % {"error": error})
            return None

        try:
            (user, apikey) = self.NPCommand.get_text().split(';')
        except ValueError:
            log.addwarning(
                _("ERROR: lastfm: Please provide both your lastfm username and API key"
                  ))
            return None

        conn.request("GET",
                     "/2.0/?method=user.getrecenttracks&user="******"&api_key=" + apikey + "&format=json",
                     headers={"User-Agent": "Nicotine+"})
        resp = conn.getresponse()
        data = resp.read().decode("utf-8")

        if resp.status != 200 or resp.reason != "OK":
            log.addwarning(
                _("ERROR: lastfm: Could not get recent track from audioscrobbler: %(error)s"
                  ) % {"error": str(data)})
            return None

        json_api = json.loads(data)
        lastplayed = json_api["recenttracks"]["track"][0]

        self.title["artist"] = lastplayed["artist"]["#text"]
        self.title["title"] = lastplayed["name"]
        self.title["album"] = lastplayed["album"]["#text"]
        self.title["nowplaying"] = "%s: %s - %s - %s" % (
            _("Last played"), self.title["artist"], self.title["album"],
            self.title["title"])

        return True
コード例 #25
0
ファイル: shares.py プロジェクト: lene/nicotine-plus
    def getFilesListUnicode(self,
                            mtimes,
                            oldmtimes,
                            oldlist,
                            yieldcall=None,
                            progress=None,
                            rebuild=False):
        """ Get a list of files with their filelength, bitrate and track length in seconds """

        list = {}
        count = 0

        for directory in mtimes:

            directory = os.path.expanduser(directory)
            virtualdir = self.real2virtual(directory)
            count += 1

            if progress:
                percent = float(count) / len(mtimes)
                if percent <= 1.0:
                    gobject.idle_add(progress.set_fraction, percent)

            # force Unicode for reading from disk
            u_directory = "%s" % directory
            str_directory = str(directory)  # noqa: F841

            if self.hiddenCheck({'dir': directory}):
                continue

            if directory in oldmtimes and directory not in oldlist:
                # Partial information, happened with unicode paths that N+ couldn't handle properly
                del oldmtimes[directory]

            if not rebuild and directory in oldmtimes:
                if mtimes[directory] == oldmtimes[directory]:
                    if os.path.exists(directory):
                        try:
                            list[virtualdir] = oldlist[virtualdir]
                            continue
                        except KeyError:
                            log.addwarning(
                                _("Inconsistent cache for '%(vdir)s', rebuilding '%(dir)s'"
                                  ) % {
                                      'vdir': virtualdir,
                                      'dir': directory
                                  })
                    else:
                        log.adddebug(
                            _("Dropping missing directory %(dir)s") %
                            {'dir': directory})
                        continue

            list[virtualdir] = []

            try:
                contents = os.listdir(u_directory)
            except OSError as errtuple:
                print(str(errtuple))
                self.logMessage(str(errtuple))
                continue

            contents.sort()

            for filename in contents:

                if self.hiddenCheck({'dir': directory, 'file': filename}):
                    continue

                path = os.path.join(directory, filename)
                s_path = str(path)
                ppath = str(path)

                s_filename = str(filename)
                try:
                    # try to force Unicode for reading from disk
                    isfile = os.path.isfile(ppath)
                except OSError as errtuple:
                    message = _("Scanning Error: %(error)s Path: %(path)s") % {
                        'error': errtuple,
                        'path': path
                    }
                    print(str(message))
                    self.logMessage(message)
                    displayTraceback(sys.exc_info()[2])
                    continue
                else:
                    if isfile:
                        # Get the metadata of the file via mutagen
                        data = self.getFileInfoUnicode(s_filename, s_path)
                        if data is not None:
                            list[virtualdir].append(data)

                if yieldcall is not None:
                    yieldcall()

        return list
コード例 #26
0
ファイル: config.py プロジェクト: zniavre/nicotine-plus
    def readConfig(self):

        self.sections['transfers']['downloads'] = []

        if exists(os.path.join(self.data_dir, 'transfers.pickle')):
            # <1.2.13 stored transfers inside the main config
            try:
                handle = open(os.path.join(self.data_dir, 'transfers.pickle'),
                              'rb')
            except IOError as inst:
                log.addwarning(
                    _("Something went wrong while opening your transfer list: %(error)s"
                      ) % {'error': str(inst)})
            else:
                try:
                    self.sections['transfers'][
                        'downloads'] = RestrictedUnpickler(handle).load()
                except Exception as inst:
                    log.addwarning(
                        _("Something went wrong while reading your transfer list: %(error)s"
                          ) % {'error': str(inst)})
            try:
                handle.close()
            except Exception:
                pass

        path, fn = os.path.split(self.filename)
        try:
            if not os.path.isdir(path):
                os.makedirs(path)
        except OSError as msg:
            log.addwarning("Can't create directory '%s', reported error: %s" %
                           (path, msg))

        try:
            if not os.path.isdir(self.data_dir):
                os.makedirs(self.data_dir)
        except OSError as msg:
            log.addwarning("Can't create directory '%s', reported error: %s" %
                           (path, msg))

        # Transition from 1.2.16 -> 1.4.0
        # Do the cleanup early so we don't get the annoying
        # 'Unknown config option ...' message
        self.removeOldOption("transfers", "pmqueueddir")
        self.removeOldOption("server", "lastportstatuscheck")
        self.removeOldOption("server", "serverlist")
        self.removeOldOption("userinfo", "descrutf8")
        self.removeOldOption("ui", "enabletrans")
        self.removeOldOption("ui", "mozembed")
        self.removeOldOption("ui", "open_in_mozembed")
        self.removeOldOption("ui", "tooltips")
        self.removeOldOption("ui", "transalpha")
        self.removeOldOption("ui", "transfilter")
        self.removeOldOption("ui", "transtint")
        self.removeOldOption("language", "language")
        self.removeOldOption("language", "setlanguage")
        self.removeOldSection("language")

        # Transition from 1.4.1 -> 1.4.2
        self.removeOldOption("columns", "downloads")
        self.removeOldOption("columns", "uploads")

        # Remove old encoding settings (1.4.3)
        self.removeOldOption("server", "enc")
        self.removeOldOption("server", "fallbackencodings")
        self.removeOldOption("server", "roomencoding")
        self.removeOldOption("server", "userencoding")

        # Remove soundcommand config, replaced by GSound (1.4.3)
        self.removeOldOption("ui", "soundcommand")

        # Remove old column widths in preparation for "group by folder"-feature
        self.removeOldOption("columns", "search")
        self.removeOldOption("columns", "search_widths")
        self.removeOldOption("columns", "downloads_columns")
        self.removeOldOption("columns", "downloads_widths")
        self.removeOldOption("columns", "uploads_columns")
        self.removeOldOption("columns", "uploads_widths")

        # Remove auto-retry failed downloads-option, this is now default behavior
        self.removeOldOption("transfers", "autoretry_downloads")

        # Remove old notification/sound settings
        self.removeOldOption("transfers", "shownotification")
        self.removeOldOption("transfers", "shownotificationperfolder")
        self.removeOldOption("ui", "soundenabled")
        self.removeOldOption("ui", "soundtheme")
        self.removeOldOption("ui", "tab_colors")
        self.removeOldOption("ui", "tab_icons")

        # Remove dropped offline user text color in search results
        self.removeOldOption("ui", "searchoffline")

        # Seems to be superseded by ("server", "private_chatrooms")
        self.removeOldOption("private_rooms", "enabled")

        # Remove everything ticker-related, no longer necessary after the introduction of room walls
        self.removeOldSection("ticker")

        # Checking for unknown section/options
        unknown1 = [
            'login', 'passw', 'enc', 'downloaddir', 'uploaddir', 'customban',
            'descr', 'pic', 'logsdir', 'roomlogsdir', 'privatelogsdir',
            'incompletedir', 'autoreply', 'afterfinish', 'downloadregexp',
            'afterfolder', 'default', 'chatfont', 'npothercommand', 'npplayer',
            'npformat', 'private_timestamp', 'rooms_timestamp', 'log_timestamp'
        ]

        unknown2 = {
            'ui': [
                "roomlistcollapsed", "tab_select_previous", "tabclosers",
                "tab_colors", "tab_reorderable", "buddylistinchatrooms",
                "trayicon", "showaway", "usernamehotspots", "exitdialog",
                "tab_icons", "spellcheck", "modes_order", "modes_visible",
                "chat_hidebuttons", "tab_status_icons", "notexists",
                "speechenabled", "enablefilters", "width", "height",
                "xposition", "yposition", "labelmain", "labelrooms",
                "labelprivate", "labelinfo", "labelbrowse", "labelsearch"
            ],
            'words': [
                "completion", "censorwords", "replacewords", "autoreplaced",
                "censored", "characters", "tab", "cycle", "dropdown",
                "roomnames", "buddies", "roomusers", "commands", "aliases",
                "onematch"
            ]
        }

        for i in self.parser.sections():
            for j in self.parser.options(i):
                val = self.parser.get(i, j, raw=1)
                if i not in self.sections:
                    log.addwarning(_("Unknown config section '%s'") % i)
                elif j not in self.sections[i] and not (j == "filter"
                                                        or i in ('plugins', )):
                    log.addwarning(
                        _("Unknown config option '%(option)s' in section '%(section)s'"
                          ) % {
                              'option': j,
                              'section': i
                          })
                elif j in unknown1 or (i in unknown2 and j not in unknown2[i]):
                    if val is not None and val != "None":
                        self.sections[i][j] = val
                    else:
                        self.sections[i][j] = None
                else:
                    try:
                        self.sections[i][j] = literal_eval(val)
                    except Exception:
                        self.sections[i][j] = None
                        log.addwarning(
                            "CONFIG ERROR: Couldn't decode '%s' section '%s' value '%s'"
                            % (str(j), str(i), str(val)))

        # Convert fs-based shared to virtual shared (pre 1.4.0)
        def _convert_to_virtual(x):
            if isinstance(x, tuple):
                return x
            virtual = x.replace('/', '_').replace('\\', '_').strip('_')
            log.addwarning(
                "Renaming shared folder '%s' to '%s'. A rescan of your share is required."
                % (x, virtual))
            return (virtual, x)

        self.sections["transfers"]["shared"] = [
            _convert_to_virtual(x)
            for x in self.sections["transfers"]["shared"]
        ]
        self.sections["transfers"]["buddyshared"] = [
            _convert_to_virtual(x)
            for x in self.sections["transfers"]["buddyshared"]
        ]

        sharedfiles = None
        bsharedfiles = None
        sharedfilesstreams = None
        bsharedfilesstreams = None
        wordindex = None
        bwordindex = None
        fileindex = None
        bfileindex = None
        sharedmtimes = None
        bsharedmtimes = None

        shelves = [
            os.path.join(self.data_dir, "files.db"),
            os.path.join(self.data_dir, "buddyfiles.db"),
            os.path.join(self.data_dir, "streams.db"),
            os.path.join(self.data_dir, "buddystreams.db"),
            os.path.join(self.data_dir, "wordindex.db"),
            os.path.join(self.data_dir, "buddywordindex.db"),
            os.path.join(self.data_dir, "fileindex.db"),
            os.path.join(self.data_dir, "buddyfileindex.db"),
            os.path.join(self.data_dir, "mtimes.db"),
            os.path.join(self.data_dir, "buddymtimes.db")
        ]

        _opened_shelves = []
        _errors = []
        for shelvefile in shelves:
            try:
                _opened_shelves.append(
                    shelve.open(shelvefile, protocol=pickle.HIGHEST_PROTOCOL))
            except Exception:
                _errors.append(shelvefile)
                try:
                    os.unlink(shelvefile)
                    _opened_shelves.append(
                        shelve.open(shelvefile,
                                    flag='n',
                                    protocol=pickle.HIGHEST_PROTOCOL))
                except Exception as ex:
                    print(("Failed to unlink %s: %s" % (shelvefile, ex)))

        sharedfiles = _opened_shelves.pop(0)
        bsharedfiles = _opened_shelves.pop(0)
        sharedfilesstreams = _opened_shelves.pop(0)
        bsharedfilesstreams = _opened_shelves.pop(0)
        wordindex = _opened_shelves.pop(0)
        bwordindex = _opened_shelves.pop(0)
        fileindex = _opened_shelves.pop(0)
        bfileindex = _opened_shelves.pop(0)
        sharedmtimes = _opened_shelves.pop(0)
        bsharedmtimes = _opened_shelves.pop(0)

        if _errors:
            log.addwarning(
                _("Failed to process the following databases: %(names)s") %
                {'names': '\n'.join(_errors)})

            files = self.clearShares(sharedfiles, bsharedfiles,
                                     sharedfilesstreams, bsharedfilesstreams,
                                     wordindex, bwordindex, fileindex,
                                     bfileindex, sharedmtimes, bsharedmtimes)

            if files is not None:
                sharedfiles, bsharedfiles, sharedfilesstreams, bsharedfilesstreams, wordindex, bwordindex, fileindex, bfileindex, sharedmtimes, bsharedmtimes = files

            log.addwarning(
                _("Shared files database seems to be corrupted, rescan your shares"
                  ))

        self.sections["transfers"]["sharedfiles"] = sharedfiles
        self.sections["transfers"]["sharedfilesstreams"] = sharedfilesstreams
        self.sections["transfers"]["wordindex"] = wordindex
        self.sections["transfers"]["fileindex"] = fileindex
        self.sections["transfers"]["sharedmtimes"] = sharedmtimes

        self.sections["transfers"]["bsharedfiles"] = bsharedfiles
        self.sections["transfers"]["bsharedfilesstreams"] = bsharedfilesstreams
        self.sections["transfers"]["bwordindex"] = bwordindex
        self.sections["transfers"]["bfileindex"] = bfileindex
        self.sections["transfers"]["bsharedmtimes"] = bsharedmtimes

        # Setting the port range in numerical order
        self.sections["server"]["portrange"] = (
            min(self.sections["server"]["portrange"]),
            max(self.sections["server"]["portrange"]))
コード例 #27
0
ファイル: config.py プロジェクト: lene/nicotine-plus
 def _convert_to_virtual(x):
     if isinstance(x, tuple):
         return x
     virtual = x.replace('/', '_').replace('\\', '_').strip('_')
     log.addwarning("Renaming shared folder '%s' to '%s'. A rescan of your share is required." % (x, virtual))
     return (virtual, x)
コード例 #28
0
    def mpris(self):
        """ Function to get the currently playing song via dbus mpris v2 interface """

        # https://media.readthedocs.org/pdf/mpris2/latest/mpris2.pdf
        try:
            import dbus
            import dbus.glib
        except ImportError as error:
            log.addwarning(
                _("ERROR: MPRIS: failed to load dbus module: %(error)s") %
                {"error": error})
            return None

        self.bus = dbus.SessionBus()

        player = self.NPCommand.get_text()

        dbus_mpris_service = u'org.mpris.MediaPlayer2.'
        dbus_mpris_player_service = u'org.mpris.MediaPlayer2.Player'
        dbus_mpris_path = u'/org/mpris/MediaPlayer2'
        dbus_property = u'org.freedesktop.DBus.Properties'

        if not player:

            names = self.bus.list_names()
            players = []

            for name in names:
                if name.startswith(dbus_mpris_service):
                    players.append(name[len(dbus_mpris_service):])

            if not players:
                log.addwarning(
                    _("ERROR: MPRIS: Could not find a suitable MPRIS player."))
                return None

            player = players[0]
            if len(players) > 1:
                log.addwarning(
                    _("Found multiple MPRIS players: %(players)s. Using: %(player)s"
                      ) % {
                          'players': players,
                          'player': player
                      })
            else:
                log.addwarning(_("Auto-detected MPRIS player: %s.") % player)

        try:
            player_obj = self.bus.get_object(dbus_mpris_service + player,
                                             dbus_mpris_path)
            player_property_obj = dbus.Interface(player_obj,
                                                 dbus_interface=dbus_property)
            metadata = player_property_obj.Get(dbus_mpris_player_service,
                                               "Metadata")
        except Exception, exception:
            log.addwarning(
                _("ERROR: MPRIS: Something went wrong while querying %(player)s: %(exception)s"
                  ) % {
                      'player': player,
                      'exception': exception
                  })
            return None
コード例 #29
0
    def OnEnter(self, widget):

        bytes = widget.get_text()

        try:
            text = unicode(bytes, "UTF-8")
        except UnicodeDecodeError:
            log.addwarning(_("We have a problem, PyGTK get_text does not seem to return UTF-8. Please file a bug report. Bytes: %s") % (repr(bytes)))
            text = unicode(bytes, "UTF-8", "replace")

        if not text:
            widget.set_text("")
            return

        if is_alias(self.frame.np.config.aliases, text):
            import thread
            thread.start_new_thread(self.threadAlias, (text,))
            widget.set_text("")
            return

        s = text.split(" ", 1)
        cmd = s[0]
        if len(s) == 2 and s[1]:
            realargs = args = s[1]
        else:
            args = self.user
            realargs = ""

        if cmd in ("/alias", "/al"):

            AppendLine(self.ChatScroll, self.frame.np.config.AddAlias(realargs), None, "")
            if self.frame.np.config.sections["words"]["aliases"]:
                self.frame.chatrooms.roomsctrl.UpdateCompletions()
                self.frame.privatechats.UpdateCompletions()

        elif cmd in ("/unalias", "/un"):

            AppendLine(self.ChatScroll, self.frame.np.config.Unalias(realargs), None, "")
            if self.frame.np.config.sections["words"]["aliases"]:
                self.frame.chatrooms.roomsctrl.UpdateCompletions()
                self.frame.privatechats.UpdateCompletions()

        elif cmd in ["/join", "/j"]:
            self.frame.np.queue.put(slskmessages.JoinRoom(args))

        elif cmd in ["/w", "/whois", "/info"]:
            if args:
                self.frame.LocalUserInfoRequest(args)
                self.frame.OnUserInfo(None)

        elif cmd in ["/b", "/browse"]:
            if args:
                self.frame.BrowseUser(args)
                self.frame.OnUserBrowse(None)

        elif cmd == "/ip":
            if args:
                user = args
                if user not in self.frame.np.ip_requested:
                    self.frame.np.ip_requested.append(user)
                self.frame.np.queue.put(slskmessages.GetPeerAddress(user))

        elif cmd == "/pm":
            if realargs:
                self.frame.privatechats.SendMessage(realargs, None, 1)

        elif cmd in ["/m", "/msg"]:
            if realargs:
                s = realargs.split(" ", 1)
                user = s[0]
                if len(s) == 2:
                    msg = s[1]
                else:
                    msg = None

                self.frame.privatechats.SendMessage(user, msg)

        elif cmd in ["/s", "/search"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 0)
                self.frame.OnSearch(None)

        elif cmd in ["/us", "/usearch"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 3, [self.user])
                self.frame.OnSearch(None)

        elif cmd in ["/rs", "/rsearch"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 1)
                self.frame.OnSearch(None)

        elif cmd in ["/bs", "/bsearch"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 2)
                self.frame.OnSearch(None)

        elif cmd in ["/ad", "/add", "/buddy"]:
            if args:
                self.frame.userlist.AddToList(args)

        elif cmd in ["/rem", "/unbuddy"]:
            if args:
                self.frame.userlist.RemoveFromList(args)

        elif cmd == "/ban":
            if args:
                self.frame.BanUser(args)

        elif cmd == "/ignore":
            if args:
                self.frame.IgnoreUser(args)

        elif cmd == "/ignoreip":
            if args:
                self.frame.IgnoreIP(args)

        elif cmd == "/unban":
            if args:
                self.frame.UnbanUser(args)

        elif cmd == "/unignore":
            if args:
                self.frame.UnignoreUser(args)

        elif cmd == "/ctcpversion":
            if args:
                self.frame.privatechats.SendMessage(args, CTCP_VERSION, 1, bytestring=True)

        elif cmd in ["/clear", "/cl"]:
            self.ChatScroll.get_buffer().set_text("")

        elif cmd in ["/a", "/away"]:
            self.frame.OnAway(None)

        elif cmd in ["/q", "/quit", "/exit"]:
            self.frame.OnExit(None)
            return

        elif cmd in ["/c", "/close"]:
            self.OnClose(None)

        elif cmd == "/now":
            self.NowPlayingThread()

        elif cmd == "/detach":
            self.Detach()

        elif cmd == "/attach":
            self.Attach()

        elif cmd == "/rescan":
            self.frame.OnRescan()

        elif cmd[:1] == "/" and self.frame.pluginhandler.TriggerPrivateCommandEvent(self.user, cmd[1:], args):
            pass

        elif cmd and cmd[:1] == "/" and cmd != "/me" and cmd[:2] != "//":
            self.frame.logMessage(_("Command %s is not recognized") % text)
            return

        else:

            if text[:2] == "//":
                text = text[1:]

            if self.chats.connected:
                self.SendMessage(text)
                widget.set_text("")

            return

        widget.set_text("")
コード例 #30
0
ファイル: privatechat.py プロジェクト: zuccon/nicotine-plus
    def OnEnter(self, widget):

        bytes = widget.get_text()

        try:
            text = unicode(bytes, "UTF-8")
        except UnicodeDecodeError:
            log.addwarning(
                _("We have a problem, PyGTK get_text does not seem to return UTF-8. Please file a bug report. Bytes: %s"
                  ) % (repr(bytes)))
            text = unicode(bytes, "UTF-8", "replace")

        if not text:
            widget.set_text("")
            return

        if is_alias(self.frame.np.config.aliases, text):
            import thread
            thread.start_new_thread(self.threadAlias, (text, ))
            widget.set_text("")
            return

        s = text.split(" ", 1)
        cmd = s[0]
        if len(s) == 2 and s[1]:
            realargs = args = s[1]
        else:
            args = self.user
            realargs = ""

        if cmd in ("/alias", "/al"):

            AppendLine(self.ChatScroll,
                       self.frame.np.config.AddAlias(realargs), None, "")
            if self.frame.np.config.sections["words"]["aliases"]:
                self.frame.chatrooms.roomsctrl.UpdateCompletions()
                self.frame.privatechats.UpdateCompletions()

        elif cmd in ("/unalias", "/un"):

            AppendLine(self.ChatScroll, self.frame.np.config.Unalias(realargs),
                       None, "")
            if self.frame.np.config.sections["words"]["aliases"]:
                self.frame.chatrooms.roomsctrl.UpdateCompletions()
                self.frame.privatechats.UpdateCompletions()

        elif cmd in ["/join", "/j"]:
            self.frame.np.queue.put(slskmessages.JoinRoom(args))

        elif cmd in ["/w", "/whois", "/info"]:
            if args:
                self.frame.LocalUserInfoRequest(args)
                self.frame.OnUserInfo(None)

        elif cmd in ["/b", "/browse"]:
            if args:
                self.frame.BrowseUser(args)
                self.frame.OnUserBrowse(None)

        elif cmd == "/ip":
            if args:
                user = args
                if user not in self.frame.np.ip_requested:
                    self.frame.np.ip_requested.append(user)
                self.frame.np.queue.put(slskmessages.GetPeerAddress(user))

        elif cmd == "/pm":
            if realargs:
                self.frame.privatechats.SendMessage(realargs, None, 1)

        elif cmd in ["/m", "/msg"]:
            if realargs:
                s = realargs.split(" ", 1)
                user = s[0]
                if len(s) == 2:
                    msg = s[1]
                else:
                    msg = None

                self.frame.privatechats.SendMessage(user, msg)

        elif cmd in ["/s", "/search"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 0)
                self.frame.OnSearch(None)

        elif cmd in ["/us", "/usearch"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 3, [self.user])
                self.frame.OnSearch(None)

        elif cmd in ["/rs", "/rsearch"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 1)
                self.frame.OnSearch(None)

        elif cmd in ["/bs", "/bsearch"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 2)
                self.frame.OnSearch(None)

        elif cmd in ["/ad", "/add", "/buddy"]:
            if args:
                self.frame.userlist.AddToList(args)

        elif cmd in ["/rem", "/unbuddy"]:
            if args:
                self.frame.userlist.RemoveFromList(args)

        elif cmd == "/ban":
            if args:
                self.frame.BanUser(args)

        elif cmd == "/ignore":
            if args:
                self.frame.IgnoreUser(args)

        elif cmd == "/ignoreip":
            if args:
                self.frame.IgnoreIP(args)

        elif cmd == "/unban":
            if args:
                self.frame.UnbanUser(args)

        elif cmd == "/unignore":
            if args:
                self.frame.UnignoreUser(args)

        elif cmd == "/ctcpversion":
            if args:
                self.frame.privatechats.SendMessage(args,
                                                    CTCP_VERSION,
                                                    1,
                                                    bytestring=True)

        elif cmd in ["/clear", "/cl"]:
            self.ChatScroll.get_buffer().set_text("")

        elif cmd in ["/a", "/away"]:
            self.frame.OnAway(None)

        elif cmd in ["/q", "/quit", "/exit"]:
            self.frame.OnExit(None)
            return

        elif cmd in ["/c", "/close"]:
            self.OnClose(None)

        elif cmd == "/now":
            self.NowPlayingThread()

        elif cmd == "/detach":
            self.Detach()

        elif cmd == "/attach":
            self.Attach()

        elif cmd == "/rescan":
            self.frame.OnRescan()

        elif cmd[:
                 1] == "/" and self.frame.pluginhandler.TriggerPrivateCommandEvent(
                     self.user, cmd[1:], args):
            pass

        elif cmd and cmd[:1] == "/" and cmd != "/me" and cmd[:2] != "//":
            self.frame.logMessage(_("Command %s is not recognized") % text)
            return

        else:

            if text[:2] == "//":
                text = text[1:]

            if self.chats.connected:
                self.SendMessage(text)
                widget.set_text("")

            return

        widget.set_text("")
コード例 #31
0
ファイル: nowplaying.py プロジェクト: emilazy/nicotine-plus
    def mpris(self):
        """ Function to get the currently playing song via dbus mpris v2 interface """

        # https://media.readthedocs.org/pdf/mpris2/latest/mpris2.pdf
        try:
            import dbus
            import dbus.glib
        except ImportError as error:
            log.addwarning(
                _("ERROR: MPRIS: failed to load dbus module: %(error)s") %
                {"error": error})
            return None

        self.bus = dbus.SessionBus()

        player = self.NPCommand.get_text()

        dbus_mpris_service = 'org.mpris.MediaPlayer2.'
        dbus_mpris_player_service = 'org.mpris.MediaPlayer2.Player'
        dbus_mpris_path = '/org/mpris/MediaPlayer2'
        dbus_property = 'org.freedesktop.DBus.Properties'

        if not player:

            names = self.bus.list_names()
            players = []

            for name in names:
                if name.startswith(dbus_mpris_service):
                    players.append(name[len(dbus_mpris_service):])

            if not players:
                log.addwarning(
                    _("ERROR: MPRIS: Could not find a suitable MPRIS player."))
                return None

            player = players[0]
            if len(players) > 1:
                log.addwarning(
                    _("Found multiple MPRIS players: %(players)s. Using: %(player)s"
                      ) % {
                          'players': players,
                          'player': player
                      })
            else:
                log.addwarning(_("Auto-detected MPRIS player: %s.") % player)

        try:
            player_obj = self.bus.get_object(dbus_mpris_service + player,
                                             dbus_mpris_path)
            player_property_obj = dbus.Interface(player_obj,
                                                 dbus_interface=dbus_property)
            metadata = player_property_obj.Get(dbus_mpris_player_service,
                                               "Metadata")
        except Exception as exception:
            log.addwarning(
                _("ERROR: MPRIS: Something went wrong while querying %(player)s: %(exception)s"
                  ) % {
                      'player': player,
                      'exception': exception
                  })
            return None

        self.title['program'] = player
        list_mapping = [('xesam:artist', 'artist')]

        for (source, dest) in list_mapping:
            try:
                self.title[dest] = '+'.join(metadata[source])
            except KeyError:
                self.title[dest] = '?'

        mapping = [('xesam:title', 'title'), ('xesam:album', 'album'),
                   ('xesam:comment', 'comment'),
                   ('xesam:audioBitrate', 'bitrate'),
                   ('xesak:trackNumber', 'track')]

        for (source, dest) in mapping:
            try:
                self.title[dest] = str(metadata[source])
            except KeyError:
                self.title[dest] = '?'

        # The length is in microseconds, and be represented as a signed 64-bit integer.
        try:
            self.title['length'] = self.get_length_time(
                metadata['mpris:length'] / 1000000)
        except KeyError:
            self.title['length'] = '?'

        if self.title['artist'] != "":
            self.title['nowplaying'] += self.title['artist']

        if self.title['title'] != "":
            self.title['nowplaying'] += " - " + self.title['title']

        return True
コード例 #32
0
ファイル: nowplaying.py プロジェクト: emilazy/nicotine-plus
    def xmms2(self):
        """ Function to get xmms2 currently playing song """

        # To communicate with xmms2d, you need an instance of the xmmsclient.XMMS object, which abstracts the connection
        try:
            import xmmsclient
        except ImportError as error:
            log.addwarning(
                _("ERROR: xmms2: failed to load xmmsclient module: %(error)s")
                % {"error": error})
            return None

        xmms = xmmsclient.XMMS("NPP")

        # Now we need to connect to xmms2d
        try:
            xmms.connect(os.getenv("XMMS_PATH"))
        except IOError as error:
            log.addwarning(
                _("ERROR: xmms2: connecting failed: %(error)s") %
                {"error": error})
            return None

        # Retrieve the current playing entry
        result = xmms.playback_current_id()
        result.wait()
        if result.iserror():
            log.addwarning(
                _("ERROR: xmms2: playback current id error: %(error)s") %
                {"error": result.get_error()})
            return None

        id = result.value()

        # Entry 0 is non valid
        if id == 0:
            log.addwarning(_("ERROR: xmms2: nothing is playing"))
            return None

        result = xmms.medialib_get_info(id)
        result.wait()

        # This can return error if the id is not in the medialib
        if result.iserror():
            log.addwarning(
                _("ERROR: xmms2: medialib get info error: %(error)s") %
                {"error": result.get_error()})
            return None

        # Extract entries from the dict
        minfo = result.value()

        try:
            self.title["artist"] = str(minfo["artist"])
            self.title["nowplaying"] = str(minfo["artist"])
        except KeyError:
            pass

        try:
            self.title["title"] = str(minfo["title"])
            self.title["nowplaying"] += " - " + str(minfo["title"])
        except KeyError:
            pass

        try:
            self.title["album"] = str(minfo["album"])
        except KeyError:
            pass

        try:
            self.title["bitrate"] = str(minfo["bitrate"])
        except KeyError:
            pass

        try:
            self.title["filename"] = str(minfo["url"])
        except KeyError:
            pass

        try:
            self.title["length"] = self.get_length_time(minfo["duration"] /
                                                        1000)
        except KeyError:
            pass

        try:
            self.title["track"] = str(minfo["tracknr"])
        except KeyError:
            pass

        try:
            self.title["year"] = str(minfo["date"])
        except KeyError:
            pass

        return True
コード例 #33
0
    def writeConfiguration(self):

        external_sections = [
            "sharedfiles", "sharedfilesstreams", "wordindex", "fileindex",
            "sharedmtimes", "bsharedfiles", "bsharedfilesstreams",
            "bwordindex", "bfileindex", "bsharedmtimes", "downloads"
        ]

        for i in self.sections:
            if not self.parser.has_section(i):
                self.parser.add_section(i)
            for j in self.sections[i]:
                if j not in external_sections:
                    self.parser.set(i, j, self.sections[i][j])
                else:
                    self.parser.remove_option(i, j)

        path, fn = os.path.split(self.filename)
        try:
            if not os.path.isdir(path):
                os.makedirs(path)
        except OSError as msg:
            log.addwarning(_("Can't create directory '%(path)s', reported error: %(error)s") % {'path': path, 'error': msg})

        oldumask = os.umask(0o077)

        try:
            f = open(self.filename + ".new", "w", encoding="utf-8")
        except IOError as e:
            log.addwarning(_("Can't save config file, I/O error: %s") % e)
            return
        else:
            try:
                self.parser.write(f)
            except IOError as e:
                log.addwarning(_("Can't save config file, I/O error: %s") % e)
                return
            else:
                f.close()

        os.umask(oldumask)

        # A paranoid precaution since config contains the password
        try:
            os.chmod(self.filename, 0o600)
        except Exception:
            pass

        try:
            s = os.stat(self.filename)
            if s.st_size > 0:
                try:
                    if os.path.exists(self.filename + ".old"):
                        os.remove(self.filename + ".old")
                except OSError:
                    log.addwarning(_("Can't remove %s" % self.filename + ".old"))
                try:
                    os.rename(self.filename, self.filename + ".old")
                except OSError as error:
                    log.addwarning(_("Can't back config file up, error: %s") % error)
        except OSError:
            pass

        try:
            os.rename(self.filename + ".new", self.filename)
        except OSError as error:
            log.addwarning(_("Can't rename config file, error: %s") % error)
コード例 #34
0
    def readConfig(self):

        self.sections['transfers']['downloads'] = []

        if exists(os.path.join(self.data_dir, 'transfers.pickle')):
            # <1.2.13 stored transfers inside the main config
            try:
                handle = open(os.path.join(self.data_dir, 'transfers.pickle'), 'rb')
            except IOError as inst:
                log.addwarning(_("Something went wrong while opening your transfer list: %(error)s") % {'error': str(inst)})
            else:
                try:
                    self.sections['transfers']['downloads'] = RestrictedUnpickler(handle).load()
                except Exception as inst:
                    log.addwarning(_("Something went wrong while reading your transfer list: %(error)s") % {'error': str(inst)})
            try:
                handle.close()
            except Exception:
                pass

        path, fn = os.path.split(self.filename)
        try:
            if not os.path.isdir(path):
                os.makedirs(path)
        except OSError as msg:
            log.addwarning("Can't create directory '%s', reported error: %s" % (path, msg))

        try:
            if not os.path.isdir(self.data_dir):
                os.makedirs(self.data_dir)
        except OSError as msg:
            log.addwarning("Can't create directory '%s', reported error: %s" % (path, msg))

        # Transition from 1.2.16 -> 1.4.0
        # Do the cleanup early so we don't get the annoying
        # 'Unknown config option ...' message
        self.removeOldOption("transfers", "pmqueueddir")
        self.removeOldOption("server", "lastportstatuscheck")
        self.removeOldOption("server", "serverlist")
        self.removeOldOption("userinfo", "descrutf8")
        self.removeOldOption("ui", "enabletrans")
        self.removeOldOption("ui", "mozembed")
        self.removeOldOption("ui", "open_in_mozembed")
        self.removeOldOption("ui", "tooltips")
        self.removeOldOption("ui", "transalpha")
        self.removeOldOption("ui", "transfilter")
        self.removeOldOption("ui", "transtint")
        self.removeOldOption("language", "language")
        self.removeOldOption("language", "setlanguage")
        self.removeOldSection("language")

        # Transition from 1.4.1 -> 1.4.2
        self.removeOldOption("columns", "downloads")
        self.removeOldOption("columns", "uploads")

        # Remove old encoding settings (1.4.3)
        self.removeOldOption("server", "enc")
        self.removeOldOption("server", "fallbackencodings")
        self.removeOldOption("server", "roomencoding")
        self.removeOldOption("server", "userencoding")

        # Remove soundcommand config, replaced by GSound (1.4.3)
        self.removeOldOption("ui", "soundcommand")

        # Remove old column widths in preparation for "group by folder"-feature
        self.removeOldOption("columns", "search")
        self.removeOldOption("columns", "search_widths")
        self.removeOldOption("columns", "downloads_columns")
        self.removeOldOption("columns", "downloads_widths")
        self.removeOldOption("columns", "uploads_columns")
        self.removeOldOption("columns", "uploads_widths")

        # Remove auto-retry failed downloads-option, this is now default behavior
        self.removeOldOption("transfers", "autoretry_downloads")

        # Remove old notification/sound settings
        self.removeOldOption("transfers", "shownotification")
        self.removeOldOption("transfers", "shownotificationperfolder")
        self.removeOldOption("ui", "soundenabled")
        self.removeOldOption("ui", "soundtheme")
        self.removeOldOption("ui", "tab_colors")
        self.removeOldOption("ui", "tab_icons")

        # Remove dropped offline user text color in search results
        self.removeOldOption("ui", "searchoffline")

        # Seems to be superseded by ("server", "private_chatrooms")
        self.removeOldOption("private_rooms", "enabled")

        # Remove everything ticker-related, no longer necessary after the introduction of room walls
        self.removeOldSection("ticker")

        # Remove old log folder option, superseded by individual log folders for transfers and debug messages
        self.removeOldOption("logging", "logsdir")

        # Checking for unknown section/options
        unknown1 = [
            'login', 'passw', 'enc', 'downloaddir', 'uploaddir', 'customban',
            'descr', 'pic', 'transferslogsdir', 'roomlogsdir', 'privatelogsdir',
            'incompletedir', 'autoreply', 'afterfinish', 'downloadregexp',
            'afterfolder', 'default', 'chatfont', 'npothercommand', 'npplayer',
            'npformat', 'private_timestamp', 'rooms_timestamp', 'log_timestamp',
            'debuglogsdir'
        ]

        unknown2 = {
            'ui': [
                "roomlistcollapsed", "tab_select_previous", "tabclosers",
                "tab_colors", "tab_reorderable", "buddylistinchatrooms", "trayicon",
                "showaway", "usernamehotspots", "exitdialog",
                "tab_icons", "spellcheck", "modes_order", "modes_visible",
                "chat_hidebuttons", "tab_status_icons", "notexists",
                "speechenabled", "enablefilters", "width",
                "height", "xposition", "yposition", "labelmain", "labelrooms",
                "labelprivate", "labelinfo", "labelbrowse", "labelsearch", "maximized",
                "dark_mode"
            ],
            'words': [
                "completion", "censorwords", "replacewords", "autoreplaced",
                "censored", "characters", "tab", "cycle", "dropdown",
                "roomnames", "buddies", "roomusers", "commands",
                "aliases", "onematch"
            ]
        }

        for i in self.parser.sections():
            for j in self.parser.options(i):
                val = self.parser.get(i, j, raw=1)
                if i not in self.sections:
                    log.addwarning(_("Unknown config section '%s'") % i)
                elif j not in self.sections[i] and not (j == "filter" or i in ('plugins',)):
                    log.addwarning(_("Unknown config option '%(option)s' in section '%(section)s'") % {'option': j, 'section': i})
                elif j in unknown1 or (i in unknown2 and j not in unknown2[i]):
                    if val is not None and val != "None":
                        self.sections[i][j] = val
                    else:
                        self.sections[i][j] = None
                else:
                    try:
                        self.sections[i][j] = literal_eval(val)
                    except Exception:
                        self.sections[i][j] = None
                        log.addwarning("CONFIG ERROR: Couldn't decode '%s' section '%s' value '%s'" % (str(j), str(i), str(val)))

        # Setting the port range in numerical order
        self.sections["server"]["portrange"] = (min(self.sections["server"]["portrange"]), max(self.sections["server"]["portrange"]))
コード例 #35
0
ファイル: nicotine.py プロジェクト: swak/nicotine-plus
def run():
    renameprocess("nicotine")
    import locale

    # Win32 hack to fix LANG and LC_ALL environnment variables with unix compliant language code
    # See pynicotine/libi18n.py
    if win32:
        import pynicotine.libi18n

        pynicotine.libi18n.fix_locale()
        del pynicotine.libi18n
    try:
        locale.setlocale(locale.LC_ALL, "")
    except:
        log.addwarning(_("Cannot set locale"))

    import gettext

    gettext.textdomain("nicotine")

    import sys, getopt, os.path

    try:
        opts, args = getopt.getopt(
            sys.argv[1:],
            "hc:p:tdvswb:",
            [
                "help",
                "config=",
                "plugins=",
                "profile",
                "enable-trayicon",
                "disable-trayicon",
                "enable-rgba",
                "disable-rgba",
                "version",
                "hidden",
                "disable-webbrowser",
                "bindip=",
            ],
        )
    except getopt.GetoptError:
        # print help information and exit:
        usage()
        sys.exit(2)

    if win32:
        try:
            mydir = os.path.join(os.environ["APPDATA"], "nicotine")
        except KeyError:
            # windows 9x?
            mydir, x = os.path.split(sys.argv[0])
        config = os.path.join(mydir, "config", "config")
        plugins = os.path.join(mydir, "plugins")
    else:
        config = os.path.join(os.path.expanduser("~"), ".nicotine", "config")
        plugins = os.path.join(os.path.expanduser("~"), ".nicotine", "plugins")
    profile = 0
    trayicon = 1
    webbrowser = True
    tryrgba = False
    hidden = False
    bindip = None
    for o, a in opts:
        if o in ("-h", "--help"):
            usage()
            sys.exit()
        if o in ("-c", "--config"):
            config = a
        if o in ("-p", "--plugins"):
            plugins = a
        if o in ("-b", "--bindip"):
            bindip = a
        if o == "--profile":
            profile = 1
        if o in ("-t", "--enable-trayicon"):
            trayicon = 1
        if o in ("-d", "--disable-trayicon"):
            trayicon = 0
        if o in ("-w", "--disable-webbrowser"):
            webbrowser = False
        if o in ("-r", "--enable-rgba"):
            tryrgba = True
        if o in ("-x", "--disable-rgba"):
            tryrgba = False
        if o in ("-s", "--hidden"):
            hidden = True
        if o in ("-v", "--version"):
            version()
            sys.exit()
    result = checkenv()
    if result is None:
        from pynicotine.gtkgui import frame

        app = frame.MainApp(config, plugins, trayicon, tryrgba, hidden, webbrowser, bindip)
        if profile:
            import hotshot

            logfile = os.path.expanduser(config) + ".profile"
            profiler = hotshot.Profile(logfile)
            log.add(_("Starting using the profiler (saving log to %s)") % logfile)
            profiler.runcall(app.MainLoop)
        else:
            app.MainLoop()
    else:
        print result
コード例 #36
0
    def AddPortMapping(self, frame, np):
        """Wrapper to redirect the Port Mapping creation to either:

        - The MiniUPnPc binary: upnpc.
        - The python binding to the MiniUPnPc binary: miniupnpc.

        Both method support creating a Port Mapping
        via the UPnP IGDv1 and IGDv2 protocol.

        Need a reference to NicotineFrame to update the interface with the WAN
        external port chosen and connect to the slsk network.
        Also need a reference to the np object to extract the internal LAN
        local from the protothread socket.

        From the UPnP IGD reference:
        http://upnp.org/specs/gw/UPnP-gw-WANIPConnection-v2-Service.pdf

        IGDv1 and IGDV2: AddPortMapping:
        This action creates a new port mapping or overwrites
        an existing mapping with the same internal client.
        If the ExternalPort and PortMappingProtocol pair is already mapped
        to another internal client, an error is returned.

        IGDv1: NewLeaseDuration:
        This argument defines the duration of the port mapping.
        If the value of this argument is 0, it means it's a static port mapping
        that never expire.

        IGDv2: NewLeaseDuration:
        This argument defines the duration of the port mapping.
        The value of this argument MUST be greater than 0.
        A NewLeaseDuration with value 0 means static port mapping,
        but static port mappings can only be created through
        an out-of-band mechanism.
        If this parameter is set to 0, default value of 604800 MUST be used.

        BTW since we don't recheck periodically ports mappings
        while nicotine+ runs, any UPnP port mapping done with IGDv2
        (any modern router does that) will expire after 7 days.
        The client won't be able to send/receive files anymore...
        """

        log.add(_('Creating Port Mapping rule via UPnP...'))

        # Hack to found out the local LAN IP
        # See https://stackoverflow.com/questions/166506/finding-local-ip-addresses-using-pythons-stdlib/28950776#28950776

        # Create a UDP socket
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        # Send a broadcast packet on a local address (doesn't need to be reachable, but MacOS requires port to be non-zero)
        s.connect(('10.255.255.255', 1))

        # This returns the "primary" IP on the local box, even if that IP is a NAT/private/internal IP.
        self.internalipaddress = s.getsockname()[0]

        # Close the socket
        s.close()

        # Store the Local LAN port
        self.internallanport = np.protothread._p.getsockname()[1]

        # The function depends on what method of configuring port mapping is
        # available
        functiontocall = getattr(self, 'AddPortMapping' + self.mode)

        try:
            functiontocall()
        except Exception as e:
            log.addwarning(_('UPnP exception: %(error)s') % {'error': str(e)})
            log.addwarning(
                _('Failed to automate the creation of ' +
                    'UPnP Port Mapping rule.'))
            return

        log.add(
            _('Managed to map external WAN port %(externalwanport)s ' +
                'on your external IP %(externalipaddress)s ' +
                'to your local host %(internalipaddress)s ' +
                'port %(internallanport)s.') %
            {
                'externalwanport': self.externalwanport,
                'externalipaddress': self.externalipaddress,
                'internalipaddress': self.internalipaddress,
                'internallanport': self.internallanport
            }
        )

        # Set the external WAN port in the GUI
        frame.networkcallback([slskmessages.IncPort(self.externalwanport)])

        # Establish the connection to the slsk network
        frame.OnConnect(-1)
コード例 #37
0
ファイル: nicotine.py プロジェクト: swak/nicotine-plus
    if v < ((1 << 16) + (99 << 8) + 16):
        return _("Your PyGTK is too old, upgrade to at least PyGTK 1.99.16")

    try:
        import GeoIP
    except ImportError:
        try:
            import _GeoIP
        except ImportError:
            msg = _(
                """Nicotine supports a country code blocker but that requires a (GPL'ed) library called GeoIP. You can find it here:
	C library:       http://www.maxmind.com/app/c
	Python bindings: http://www.maxmind.com/app/python
	(the python bindings require the C library)"""
            )
            log.addwarning(msg)

    import pynicotine.upnp as upnp

    if not upnp.upnppossible:
        log.addwarning(
            _("Disabled UPnP support due to errors: %(errors)s") % {"errors": ". Also: ".join(upnp.miniupnpc_errors)}
        )

    return None


def version():
    try:
        import pynicotine.utils
コード例 #38
0
ファイル: nowplaying.py プロジェクト: emilazy/nicotine-plus
    def GetNP(self, widget, test=None, callback=None):

        self.title_clear()

        result = None

        try:

            if self.NP_amarok.get_active():
                result = self.amarok()
            elif self.NP_audacious.get_active():
                result = self.audacious()
            elif self.NP_mpd.get_active():
                result = self.mpd()
            elif self.NP_exaile.get_active():
                result = self.exaile()
            elif self.NP_lastfm.get_active():
                result = self.lastfm()
            elif self.NP_foobar.get_active():
                result = self.foobar()
            elif self.NP_xmms2.get_active():
                result = self.xmms2()
            elif self.NP_other.get_active():
                result = self.other()
            elif self.NP_mpris.get_active():
                result = self.mpris()

        except RuntimeError:
            log.addwarning(
                _("ERROR: Could not execute now playing code. Are you sure you picked the right player?"
                  ))
            result = None

        if not result:
            return None

        # Since we need unicode instead of bytes we'll try to force such a
        # conversion. Individual player commands should have done this already
        # - this is a failsafe.
        oldtitle = copy.copy(self.title)
        self.title_clear()
        for key, value in oldtitle.items():
            try:
                self.title[key] = str(value, "UTF-8", "replace")
            except TypeError:
                self.title[key] = value  # already unicode

        title = self.NPFormat.get_child().get_text()
        title = title.replace("%", "%%")  # Escaping user supplied % symbols
        title = title.replace("$t", "%(title)s")
        title = title.replace("$a", "%(artist)s")
        title = title.replace("$b", "%(album)s")
        title = title.replace("$c", "%(comment)s")
        title = title.replace("$n", "%(nowplaying)s")
        title = title.replace("$k", "%(track)s")
        title = title.replace("$l", "%(length)s")
        title = title.replace("$y", "%(year)s")
        title = title.replace("$r", "%(bitrate)s")
        title = title.replace("$f", "%(filename)s")
        title = title.replace("$p", "%(program)s")

        title = title % self.title
        title = ' '.join(
            [x for x in title.replace('\r', '\n').split('\n') if x])

        if test:
            self.Example.set_text(title)
            return None

        if title:
            if callback:
                callback(title)
            return title

        return None
コード例 #39
0
ファイル: config.py プロジェクト: zniavre/nicotine-plus
    def clearShares(self, sharedfiles, bsharedfiles, sharedfilesstreams,
                    bsharedfilesstreams, wordindex, bwordindex, fileindex,
                    bfileindex, sharedmtimes, bsharedmtimes):

        try:
            if sharedfiles:
                sharedfiles.close()
            try:
                os.unlink(os.path.join(self.data_dir, 'files.db'))
            except Exception:
                pass
            sharedfiles = shelve.open(os.path.join(self.data_dir, "files.db"),
                                      flag='n',
                                      protocol=pickle.HIGHEST_PROTOCOL)

            if bsharedfiles:
                bsharedfiles.close()
            try:
                os.unlink(os.path.join(self.data_dir, 'buddyfiles.db'))
            except Exception:
                pass
            bsharedfiles = shelve.open(os.path.join(self.data_dir,
                                                    "buddyfiles.db"),
                                       flag='n',
                                       protocol=pickle.HIGHEST_PROTOCOL)

            if sharedfilesstreams:
                sharedfilesstreams.close()
            try:
                os.unlink(os.path.join(self.data_dir, 'streams.db'))
            except Exception:
                pass
            sharedfilesstreams = shelve.open(os.path.join(
                self.data_dir, "streams.db"),
                                             flag='n',
                                             protocol=pickle.HIGHEST_PROTOCOL)

            if bsharedfilesstreams:
                bsharedfilesstreams.close()
            try:
                os.unlink(os.path.join(self.data_dir, 'buddystreams.db'))
            except Exception:
                pass
            bsharedfilesstreams = shelve.open(os.path.join(
                self.data_dir, "buddystreams.db"),
                                              flag='n',
                                              protocol=pickle.HIGHEST_PROTOCOL)

            if wordindex:
                wordindex.close()
            try:
                os.unlink(os.path.join(self.data_dir, 'wordindex.db'))
            except Exception:
                pass
            wordindex = shelve.open(os.path.join(self.data_dir,
                                                 "wordindex.db"),
                                    flag='n',
                                    protocol=pickle.HIGHEST_PROTOCOL)

            if bwordindex:
                bwordindex.close()
            try:
                os.unlink(os.path.join(self.data_dir, 'buddywordindex.db'))
            except Exception:
                pass
            bwordindex = shelve.open(os.path.join(self.data_dir,
                                                  "buddywordindex.db"),
                                     flag='n',
                                     protocol=pickle.HIGHEST_PROTOCOL)

            if fileindex:
                fileindex.close()
            try:
                os.unlink(os.path.join(self.data_dir, 'fileindex.db'))
            except Exception:
                pass
            fileindex = shelve.open(os.path.join(self.data_dir,
                                                 "fileindex.db"),
                                    flag='n',
                                    protocol=pickle.HIGHEST_PROTOCOL)

            if bfileindex:
                bfileindex.close()
            try:
                os.unlink(os.path.join(self.data_dir, 'buddyfileindex.db'))
            except Exception:
                pass
            bfileindex = shelve.open(os.path.join(self.data_dir,
                                                  "buddyfileindex.db"),
                                     flag='n',
                                     protocol=pickle.HIGHEST_PROTOCOL)

            if sharedmtimes:
                sharedmtimes.close()
            try:
                os.unlink(os.path.join(self.data_dir, 'mtimes.db'))
            except Exception:
                pass
            sharedmtimes = shelve.open(os.path.join(self.data_dir,
                                                    "mtimes.db"),
                                       flag='n',
                                       protocol=pickle.HIGHEST_PROTOCOL)

            if bsharedmtimes:
                bsharedmtimes.close()
            try:
                os.unlink(os.path.join(self.data_dir, 'buddymtimes.db'))
            except Exception:
                pass
            bsharedmtimes = shelve.open(os.path.join(self.data_dir,
                                                     "buddymtimes.db"),
                                        flag='n',
                                        protocol=pickle.HIGHEST_PROTOCOL)
        except Exception as error:
            log.addwarning(_("Error while writing database files: %s") % error)
            return None
        return sharedfiles, bsharedfiles, sharedfilesstreams, bsharedfilesstreams, wordindex, bwordindex, fileindex, bfileindex, sharedmtimes, bsharedmtimes
コード例 #40
0
ファイル: nowplaying.py プロジェクト: emilazy/nicotine-plus
    def audacious(self):
        """ Function to get audacious currently playing song """

        slist = self.NPFormat.get_child().get_text()
        output = ""
        self.audacious_running = True

        if "$n" in slist:
            artist = self.audacious_command('current-song-tuple-data',
                                            'artist')
            title = self.audacious_command('current-song-tuple-data', 'title')
            if artist and title:
                self.title["nowplaying"] = artist + ' - ' + title

        if "$t" in slist:
            output = self.audacious_command('current-song-tuple-data', 'title')
            if output:
                self.title["title"] = output

        if "$l" in slist:
            output = self.audacious_command('current-song-length')
            if output:
                self.title["length"] = output

        if "$a" in slist:
            output = self.audacious_command('current-song-tuple-data',
                                            'artist')
            if output:
                self.title["artist"] = output

        if "$b" in slist:
            output = self.audacious_command('current-song-tuple-data', 'album')
            if output:
                self.title["album"] = output

        if "$c" in slist:
            output = self.audacious_command('current-song-tuple-data',
                                            'comment')
            if output:
                self.title["comment"] = output

        if "$k" in slist:
            output = self.audacious_command('current-song-tuple-data',
                                            'track-number')
            if output:
                self.title["track"] = output

        if "$y" in slist:
            output = self.audacious_command('current-song-tuple-data', 'year')
            if output and not output == "0":
                self.title["year"] = output

        if "$r" in slist:
            output = self.audacious_command('current-song-bitrate-kbps')
            if output:
                self.title["bitrate"] = output

        if "$f" in slist:
            path = self.audacious_command(
                'current-song-filename')  # noqa: F841

        if not self.audacious_running:
            log.addwarning(
                _("ERROR: audacious: audtool didn't detect a running Audacious session."
                  ))
            return False

        return True
コード例 #41
0
ファイル: nicotine.py プロジェクト: Mutnick/nicotine-plus
what version of python was used to build the Nicotine
binary package and what you try to run Nicotine+ with).""")

    # Require GeoIP
    try:
        import GeoIP
    except ImportError:
        try:
            import _GeoIP
        except ImportError:
            msg = _("""Nicotine+ supports a country code blocker.
That requires a (GPL'ed) library called GeoIP. You can find it here:
C library:       http://www.maxmind.com/app/c
Python bindings: http://www.maxmind.com/app/python
(the python bindings require the C library)""")
            log.addwarning(msg)

    return None


def version():
    try:
        import pynicotine.utils
        print _("Nicotine+ version %s" % pynicotine.utils.version)
    except ImportError, error:
        print _("Cannot find the pynicotine.utils module.")


def usage():
    print _("""Nicotine+ is a Soulseek client.
Usage: nicotine [OPTION]...
コード例 #42
0
ファイル: nowplaying.py プロジェクト: Mutnick/nicotine-plus
	def GetNP(self, widget, test=None, callback=None):
		self.title_clear()
		try:
			if self.NP_infopipe.get_active(): 
					result = self.xmms() 
			elif self.NP_amarok.get_active(): 
					result = self.amarok() 
			elif self.NP_amarok2.get_active(): 
					result = self.amarok2() 
			elif self.NP_audacious.get_active(): 
					result = self.audacious() 
			elif self.NP_mpd.get_active(): 
					result = self.mpd() 
			elif self.NP_banshee.get_active(): 
					result = self.banshee() 
			elif self.NP_rhythmbox.get_active():
				result = self.rhythmbox()
			elif self.NP_bmpx.get_active():
				result = self.bmpx()
			elif self.NP_exaile.get_active(): 
					result = self.exaile() 
			elif self.NP_lastfm.get_active(): 
					result = self.lastfm() 
			elif self.NP_foobar.get_active(): 
					result = self.foobar() 
			elif self.NP_other.get_active(): 
					result = self.other() 
			elif self.NP_mpris.get_active():
				result = self.mpris()
		except RuntimeError:
			log.addwarning("ERROR: Could not execute now playing code. Are you sure you picked the right player?")
			result = None
		if not result:
			return None
		# Since we need unicode instead of bytes we'll try to force such a
		# conversion. Individual player commands should have done this already
		# - this is a failsafe.
		oldtitle = copy.copy(self.title)
		self.title_clear()
		for key, value in oldtitle.iteritems():
			try:
				self.title[key] = unicode(value, "UTF-8", "replace")
			except TypeError:
				self.title[key] = value # already unicode
		title = self.NPFormat.child.get_text()
		title = title.replace("%", "%%") # Escaping user supplied % symbols
		#print "Title1: " + title
		title = title.replace("$t", "%(title)s")
		title = title.replace("$a", "%(artist)s")
		title = title.replace("$b", "%(album)s")
		title = title.replace("$c", "%(comment)s")
		title = title.replace("$n", "%(nowplaying)s")
		title = title.replace("$k", "%(track)s")
		title = title.replace("$l", "%(length)s")
		title = title.replace("$y", "%(year)s")
		title = title.replace("$r", "%(bitrate)s")
		title = title.replace("$s", "%(status)s")
		title = title.replace("$f", "%(filename)s")
		title = title.replace("$p", "%(program)s")
		#print "Title2: " + title
		title = title % self.title
		title = ' '.join([x for x in title.replace('\r', '\n').split('\n') if x])
		
		if test:
			self.Example.set_text(title)
			return None
		if title:
			if callback:
				callback(title)
			return title
		return None
コード例 #43
0
    def xmms2(self):
        """ Function to get xmms2 currently playing song """

        # To communicate with xmms2d, you need an instance of the xmmsclient.XMMS object, which abstracts the connection
        try:
            import xmmsclient
        except ImportError as error:
            log.addwarning(_("ERROR: xmms2: failed to load xmmsclient module: %(error)s") % {"error": error})
            return None

        xmms = xmmsclient.XMMS("NPP")

        # Now we need to connect to xmms2d
        try:
            xmms.connect(os.getenv("XMMS_PATH"))
        except IOError as detail:
            log.addwarning(_("ERROR: xmms2: connecting failed: %(error)s") % {"error": error})
            return None

        # Retrieve the current playing entry
        result = xmms.playback_current_id()
        result.wait()
        if result.iserror():
            log.addwarning(_("ERROR: xmms2: playback current id error: %(error)s") % {"error": result.get_error()})
            return None

        id = result.value()

        # Entry 0 is non valid
        if id == 0:
            log.addwarning(_("ERROR: xmms2: nothing is playing"))
            return None

        result = xmms.medialib_get_info(id)
        result.wait()

        # This can return error if the id is not in the medialib
        if result.iserror():
            log.addwarning(_("ERROR: xmms2: medialib get info error: %(error)s") % {"error": result.get_error()})
            return None

        # Extract entries from the dict
        minfo = result.value()

        try:
            self.title["artist"] = str(minfo["artist"])
            self.title["nowplaying"] = str(minfo["artist"])
        except KeyError:
            pass

        try:
            self.title["title"] = str(minfo["title"])
            self.title["nowplaying"] += " - " + str(minfo["title"])
        except KeyError:
            pass

        try:
            self.title["album"] = str(minfo["album"])
        except KeyError:
            pass

        try:
            self.title["bitrate"] = str(minfo["bitrate"])
        except KeyError:
            pass

        try:
            self.title["filename"] = str(minfo["url"])
        except KeyError:
            pass

        try:
            self.title["length"] = self.get_length_time(minfo["duration"] / 1000)
        except KeyError:
            pass

        try:
            self.title["track"] = str(minfo["tracknr"])
        except KeyError:
            pass

        try:
            self.title["year"] = str(minfo["date"])
        except KeyError:
            pass

        return True
コード例 #44
0
ファイル: upnp.py プロジェクト: zniavre/nicotine-plus
    def AddPortMapping(self, frame, np):
        """Wrapper to redirect the Port Mapping creation to either:

        - The MiniUPnPc binary: upnpc.
        - The python binding to the MiniUPnPc binary: miniupnpc.

        Both method support creating a Port Mapping
        via the UPnP IGDv1 and IGDv2 protocol.

        Need a reference to NicotineFrame to update the interface with the WAN
        external port chosen and connect to the slsk network.
        Also need a reference to the np object to extract the internal LAN
        local from the protothread socket.

        From the UPnP IGD reference:
        http://upnp.org/specs/gw/UPnP-gw-WANIPConnection-v2-Service.pdf

        IGDv1 and IGDV2: AddPortMapping:
        This action creates a new port mapping or overwrites
        an existing mapping with the same internal client.
        If the ExternalPort and PortMappingProtocol pair is already mapped
        to another internal client, an error is returned.

        IGDv1: NewLeaseDuration:
        This argument defines the duration of the port mapping.
        If the value of this argument is 0, it means it's a static port mapping
        that never expire.

        IGDv2: NewLeaseDuration:
        This argument defines the duration of the port mapping.
        The value of this argument MUST be greater than 0.
        A NewLeaseDuration with value 0 means static port mapping,
        but static port mappings can only be created through
        an out-of-band mechanism.
        If this parameter is set to 0, default value of 604800 MUST be used.

        BTW since we don't recheck periodically ports mappings
        while nicotine+ runs, any UPnP port mapping done with IGDv2
        (any modern router does that) will expire after 7 days.
        The client won't be able to send/receive files anymore...
        """

        log.add(_('Creating Port Mapping rule via UPnP...'))

        # Placeholder LAN IP address, updated in AddPortMappingBinary or AddPortMappingModule
        self.internalipaddress = "127.0.0.1"

        # Store the Local LAN port
        self.internallanport = np.protothread._p.getsockname()[1]
        self.externalwanport = self.internallanport

        # The function depends on what method of configuring port mapping is
        # available
        functiontocall = getattr(self, 'AddPortMapping' + self.mode)

        try:
            functiontocall()
        except Exception as e:
            log.addwarning(_('UPnP exception: %(error)s') % {'error': str(e)})
            log.addwarning(
                _('Failed to automate the creation of ' +
                  'UPnP Port Mapping rule.'))
            return

        log.adddebug(
            _('Managed to map external WAN port %(externalwanport)s ' +
              'on your external IP %(externalipaddress)s ' +
              'to your local host %(internalipaddress)s ' +
              'port %(internallanport)s.') % {
                  'externalwanport': self.externalwanport,
                  'externalipaddress': self.externalipaddress,
                  'internalipaddress': self.internalipaddress,
                  'internallanport': self.internallanport
              })
コード例 #45
0
    def audacious(self):
        """ Function to get audacious currently playing song """

        slist = self.NPFormat.child.get_text()
        output = ""
        self.audacious_running = True

        if "$n" in slist:
            artist = self.audacious_command('current-song-tuple-data', 'artist')
            title = self.audacious_command('current-song-tuple-data', 'title')
            if artist and title:
                self.title["nowplaying"] = artist + ' - ' + title

        if "$t" in slist:
            output = self.audacious_command('current-song-tuple-data', 'title')
            if output:
                self.title["title"] = output

        if "$l" in slist:
            output = self.audacious_command('current-song-length')
            if output:
                self.title["length"] = output

        if "$a" in slist:
            output = self.audacious_command('current-song-tuple-data', 'artist')
            if output:
                self.title["artist"] = output

        if "$b" in slist:
            output = self.audacious_command('current-song-tuple-data', 'album')
            if output:
                self.title["album"] = output

        if "$c" in slist:
            output = self.audacious_command('current-song-tuple-data', 'comment')
            if output:
                self.title["comment"] = output

        if "$k" in slist:
            output = self.audacious_command('current-song-tuple-data', 'track-number')
            if output:
                self.title["track"] = output

        if "$y" in slist:
            output = self.audacious_command('current-song-tuple-data', 'year')
            if output and not output == "0":
                self.title["year"] = output

        if "$r" in slist:
            output = self.audacious_command('current-song-bitrate-kbps')
            if output:
                self.title["bitrate"] = output

        if "$f" in slist:
            path = self.audacious_command('current-song-filename')

        if not self.audacious_running:
            log.addwarning(_("ERROR: audacious: audtool didn't detect a running Audacious session."))
            return False

        return True