code stringlengths 1 1.72M | language stringclasses 1 value |
|---|---|
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import urllib
import urllib2
import mechanize
import random
import re
import threading
import time
import xml.sax.saxutils
import logging
logger = logging.getLogger( "TVDownloader" )
#
# Liste d'user agent
#
listeUserAgents = [ 'Mozilla/5.0 (Windows; U; Windows NT 5.1; fr; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1',
'Mozilla/5.0 (Windows; U; Windows NT 6.0; fr; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1',
'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; fr; rv:1.9.0.3) Gecko/2008092414 Firefox/3.0.3',
'Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.0.6) Gecko/2009011913 Firefox/3.0.6',
'Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.1b2) Gecko/20081201 Firefox/3.1b2',
'Mozilla/5.0 (X11; U; Linux i686; fr; rv:1.9.1.1) Gecko/20090715 Firefox/3.5.1',
'Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.2) Gecko/20100115 Firefox/3.6',
'Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13',
'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)',
'Mozilla/5.0 (X11; U; Linux x86_64; en-us) AppleWebKit/528.5+ (KHTML, like Gecko, Safari/528.5+) midori',
'Opera/8.50 (Windows NT 5.1; U; en)',
'Opera/9.80 (X11; Linux x86_64; U; fr) Presto/2.2.15 Version/10.00',
'Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en-us) AppleWebKit/312.1 (KHTML, like Gecko) Safari/312' ]
##########
# Classe #
##########
## Classe Navigateur pour charger les pages web
class Navigateur( object ):
timeOut = 5
maxThread = 10
## Constructeur
def __init__( self ):
# Navigateur
self.navigateur = mechanize.Browser()
#
# Options du Navigateur
#
# User Agent
self.navigateur.addheaders = [ ('User-agent', random.choice( listeUserAgents ) ) ]
#
self.navigateur.set_handle_equiv( True )
# Active compression gzip
#~ self.navigateur.set_handle_gzip( True )
#
self.navigateur.set_handle_redirect( True )
# N'ajoute pas le referer a l'en-tete
self.navigateur.set_handle_referer( False )
# Ne prend pas en compte les robots.txt
self.navigateur.set_handle_robots( False )
# Ne doit pas gerer les cookies
self.navigateur.set_cookiejar( None )
logger.warning( "La classe Navigateur a ete replacee par la classe Browser" )
## Methode pour recuperer une page web
# @param URLPage URL de la page web a charger
# @return Code de la page
def getPage( self, URLPage ):
logger.info( "acces a la page %s" %( URLPage ) )
try:
# Page a charger
page = self.navigateur.open( URLPage, timeout = self.timeOut )
# Si le fichier est un XML
if( URLPage[ -4 : ] == ".xml" ):
# On la page telle quelle, sans aucun traitement
return page.read()
else: # Sinon, on va cherche a determiner son encodage
# Donnees de la page
donnees = self.unescape( page.read() )
# On recupere si possible l'encodage de la page
contentType = page.info()[ "Content-type" ]
# Type d'encodage de la page
encodagePage = ""
# On extrait l'encodage
res = re.findall( "charset=(.+)", contentType )
if( len( res ) != 0 ):
encodagePage = res[ 0 ].lower()
# Si on a trouve un encodage et qui n'est pas de l'utf-8
if( encodagePage != "" and encodagePage != "utf-8" ):
# On retourne la page dans le bon encodage
return unicode( donnees, encodagePage ).encode( 'utf-8', 'replace' )
else:
return donnees
except urllib2.URLError, erreur:
try:
logger.error( erreur.reason )
except :
pass
return ""
except:
return ""
## Methode pour recuperer plusieurs pages web
# @param listeURL Liste des URLs des pages web a charger
# @return La liste (dictionnaire) des pages web recuperees { URLPage : Page }
def getPages( self, listeURL ):
## Sous methode qui gere le telechargement d'une page (thread)
# @param URLPage URL de la page a charger
def ajoutPage( self, URLPage ):
# On a un thread lance de plus
self.lock.acquire()
self.nbThreadLances += 1
self.lock.release()
# On recupere la page web
try:
page = self.getPage( URLPage )
except:
page = ""
#~ print "DL de %s fini" %( URLPage )
# On ajoute la page a la liste et on a un thread lance de moins
self.lock.acquire()
self.listePage[ URLPage ] = page
self.nbThreadLances -= 1
self.lock.release()
self.listePage = {}
self.nbThreadLances = 0
indiceActuelListe = 0
tailleListe = len( listeURL )
self.lock = threading.Lock()
# Boucle pour lancer les threads
self.lock.acquire()
while( indiceActuelListe < tailleListe ): # Tant qu'on a pas fini de parcourir la liste
if( self.nbThreadLances < self.maxThread ): # Si on peut encore lance des threads
#~ print "Indice = %d" %( indiceActuelListe )
self.lock.release()
# On en lance un
threading.Thread( target = ajoutPage,
args = ( self, listeURL[ indiceActuelListe ] )
).start()
indiceActuelListe += 1
#~ self.lock.release()
#~ time.sleep( 0.01 ) # Legere attente pour que le thread ait le temps d'incrementer le nombre de threads lances
else: # Sinon,
# On attend un peu avant de reessayer
self.lock.release()
time.sleep( 0.1 )
#~ print self.nbThreadLances
self.lock.acquire()
self.lock.release()
# Boucle pour attendre la fin de tous les threads
self.lock.acquire()
while( self.nbThreadLances > 0 ): # Si des threads ne sont pas finis
#~ print self.nbThreadLances
# On attend un peu
self.lock.release()
time.sleep( 0.1 )
self.lock.acquire()
self.lock.release()
return self.listePage
## Methode pour recuperer une image
# @param URLPicture URL de l'image a charger
# @return les données de l'image
def getPicture( self, URLPicture ):
logger.info( "acces a l'image %s" %( URLPicture ) )
try:
# Image a charger
page = self.navigateur.open( URLPicture, timeout = self.timeOut )
# Donnees de l'image
donnees = page.read()
return donnees
except urllib2.URLError, erreur:
try:
logger.error( erreur.reason )
except :
pass
return ""
def unescape( self, texte ):
#~ def ent2chr( m ):
#~ code = m.group( 1 )
#~ if( code.isdigit() ):
#~ code = int( code )
#~ else:
#~ code = int( code[ 1 : ], 16 )
#~ if( code < 256 ):
#~ return chr( code )
#~ else:
#~ return '?'
#~
#~ texte = texte.replace( "<", "<" )
#~ texte = texte.replace( ">", ">" )
#~ texte = texte.replace( "&", "&" )
#~ texte = texte.replace( """, '"' )
#~ texte = texte.replace( "'", "'" )
#~ texte = re.sub( r'\&\#(x?[0-9a-fA-F]+);', ent2chr, texte )
return xml.sax.saxutils.unescape( texte )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier LICENSE #
#########################################
#~ Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
#~ Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
#~ Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os,os.path,pickle
from tvdcore import *
import sys
sys.path.append( ".." )
from base.Browser import Browser
##########
# Classe #
##########
## Classe abstraite Plugin dont doit heriter chacun des plugins.
#
# Les plugins doivent hériter de cette classe et redéfinir les méthodes
# #listerChaines, #listerEmissions et #listerFichiers. Dans ces méthodes il faut
# procéder au téléchargement des données demandées et les ajouter si ce n'est
# déjà fait via les méthodes #ajouterChaine, #ajouterEmission et #ajouterFichier.
# Si il n'y a pas nécessité de télécharger des données, utilisez directement les
# méthode #ajouterChaine, #ajouterEmission et #ajouterFichier dès que vous
# possédez la donnée (dans #rafraichir par exemple).
#
# L'idée est de télécharger les données générales dans #rafraichir et de les
# mettre en cache. Puis, si pour chaque chaîne ou émission il faut des
# téléchargements supplémentaires qui seraient trop important pour être tous mis
# dans #rafraichir, c'est d'utiliser les méthodes lister* pour y faire ces
# téléchargements (et donc y faire appel à add*).
#
# La méthode #listerOptions est optionnellement à redéfinir (dans le cas où il y
# aurai des options).
class Plugin(object):
NAVIGATEUR = Browser()
## @var nom
# Nom du plugin
## @var url
# Url du site internet du plugin
## @var frequence
# Nombre de jour avant le rafraichissement automatique du plugin
## @var fichierConfiguration
# Chemin du fichier de configuration
## @var fichierCache
# Chemin du fichier de cache
## Constructeur
# @param self le plugin courant
# @param nom le nom du plugin
# @param url l'url du site internet
# @param frequence la fréquence (en jour) de rafraichissement, 0 pour ne jamais rafraichir
def __init__(self, nom=None, url=None, frequence=7, logo = None):
self.pluginDatas = {"chaines":[],
"emissions":{},
"fichiers":{}}
self.pluginOptions = []
if nom == None:
logger.warn("DEPRECATED: il faut préciser le nom du plugin au constructeur")
else:
self.nom = nom
if url == None:
logger.warn("DEPRECATED: il faut préciser l'url du site du plugin au constructeur")
else:
self.url = url
self.frequence = frequence
self.fichierConfiguration = os.path.join( Constantes.REPERTOIRE_CONFIGURATION, self.nom.replace( " ", "_" )+ ".conf" )
self.fichierCache = os.path.join( Constantes.REPERTOIRE_CACHE, self.nom.replace( " ", "_" ) + ".cache" )
if logo != None:#FIXME Le logo peut être None
self.logo = os.path.join( "plugins", "img", logo )
else:
self.logo = ""
## Efface les informations mémorisées.
# @param self l'objet courant
def vider(self):
self.pluginDatas = {"chaines":[],
"emissions":{},
"fichiers":{}}
self.pluginOptions = []
## Effectue le listage des options.
# Utiliser #optionTexte, #optionCheckbox, #optionListeMultiple et #optionListeUnique pour ajouter des options
# @param self le plugin courant
# @return rien
def listerOptions(self):
pass
## Rafraichie les informations durable du plugins comme la liste des émissions.
# Y placer les traitements lourd n'ayant pas besoin d'être fait souvent.
# @param self le plugin courant
# @return Rien
def rafraichir( self ):
pass
## Effectue le listage des chaînes.
# Utiliser #ajouterChaine pour ajouter une chaîne à la liste.
# @param self le plugin courant
# @return rien
def listerChaines( self ):
pass
## Effectue le listage des émissions.
# Utiliser #ajouterEmission pour ajouter une émission à la liste.
# @param self le plugin courant
# @param chaine la chaine
# @return rien
def listerEmissions( self, chaine ):
pass
## Effectue le listage des fichiers.
# Utiliser #ajouterFichier pour ajouter un fichier à la liste.
# @param self le plugin courant
# @param emission l'emission
# @return Rien
def listerFichiers( self, emission ):
pass
## Ajoute une chaine à celle disponible pour ce plugin.
# A utiliser dans #listerChaines et en remplacement d'un retour de paramètre.
# @param self le plugin courant
# @param chaine le nom de la chaine
# @return Rien
def ajouterChaine(self, chaine):
self.pluginDatas["chaines"].append(chaine)
## Ajoute une émission à celle disponible pour ce plugin.
# A utiliser dans #listerEmissions et en remplacement d'un retour de paramètre.
# @param self le plugin courant
# @param chaine le nom de la chaine de l'émission
# @param emission le nom de l'émission
# @return Rien
def ajouterEmission(self, chaine, emission):
if not self.pluginDatas["emissions"].has_key(chaine):
self.pluginDatas["emissions"][chaine] = []
self.pluginDatas["emissions"][chaine].append(emission)
## Ajoute un fichier à ceux disponible pour ce plugin.
# A utiliser dans #listerFichiers et en remplacement d'un retour de paramètre.
# @param self le plugin courant
# @param emission l'emission du fichier
# @param fichier le fichier
# @return Rien
def ajouterFichier(self, emission, fichier):
if not self.pluginDatas["fichiers"].has_key(emission):
self.pluginDatas["fichiers"][emission] = []
self.pluginDatas["fichiers"][emission].append(fichier)
## Affiche le texte "text" dans la console avec en préfixe le nom du plugin.
# Facilite le déboguage, utilisé cette méthode plutôt que "print".
# @param self le plugin courant
# @param text le texte à afficher en console
# @param ligne paramètre inutile, conservé par rétrocompatibilité
# @return Rien
def afficher(self, text, ligne=None):
if ligne != None:
logger.warn("Le paramètre ligne n'a plus aucun effet.")
logger.info(self.nom+": "+text)
## Sauvegarde les options.
#
# Sauvegarde les options dans le fichier de configuration, ne pas utiliser.
# Les options sont sauvegardées automatiquement.
# @param self le plugin courant
# @return Rien
# @deprecated Ne fait plus rien. Ne pas uiliser.
def sauvegarderPreference(self):
logger.warn("Plugin.sauvegarderPreference(): DEPRECATED: ne fait plus rien.")
return
try:
file = open(self.fichierConfiguration, "w")
pickle.dump(self.pluginOptions, file)
file.close()
except:
logger.error("Plugin.sauvegarderPreference(): Erreur de sauvegarde")
## Charge les préférences.
#
# Charge les préférences du fichier de configuration, ne pas utiliser.
# Les options sont chargées automatiquement.
# @param self le plugin courant
# @return Rien
# @deprecated Ne fait plus rien. Ne pas uiliser.
def chargerPreference(self):
logger.warn("Plugin.chargerPreference(): DEPRECATED: ne fait plus rien.")
return
if os.path.exists(self.fichierConfiguration):
try:
file = open(self.fichierConfiguration, "r")
tmp = pickle.load(file)
file.close()
self.pluginOptions = tmp
except:
logger.error("Plugin.chargerPreference(): Erreur de chargement")
## Sauvegarde un objet dans le cache.
#
# Attention, cette méthode écrase le cache déjà enregistré.
# @param self le plugin courant
# @param objet l'objet à sauvegarder
# @return Rien
def sauvegarderCache(self, objet):
try:
file = open(self.fichierCache, "w")
pickle.dump(objet, file)
file.close()
except Exception as ex:
logger.error("Erreur de sauvegarde: "+ex.message)
## Charge le fichier de cache.
# @param self le plugin courant
# @return l'objet sauvegardé dans le cache ou None en cas d'échec
def chargerCache(self):
if os.path.exists(self.fichierCache):
try:
file = open(self.fichierCache, "r")
tmp = pickle.load(file)
file.close()
return tmp
except Exception as ex:
logger.error("Erreur de chargement: "+ex.message)
return None
else:
return None
## Renvoie la valeur d'une option
#
# L'option doit être ajouter dans #listerOptions pour que cela renvoie une valeur.
# @param self le plugin courant
# @param nom le nom de l'option
# @return la valeur de l'option, None en cas d'échec
def getOption(self, nom):
for option in self.pluginOptions:
if option.getNom() == nom:
return option.getValeur()
return None
## Ajoute une option texte.
# @param self le plugin courant
# @param nom le nom de l'option (sert d'identifiant)
# @param description la description de l'option
# @param defaut la valeur par défaut (celle qui sera présente lors de l'affichage des options)
# @return rien
def optionTexte(self, nom, description, defaut):
self.pluginOptions.append(Option(Option.TYPE_TEXTE, nom, description, defaut))
## Ajoute une option bouléen.
# @param self le plugin courant
# @param nom le nom de l'option (sert d'identifiant)
# @param description la description de l'option
# @param defaut la valeur par défaut, True pour coché, faut pour décoché
# @return rien
def optionBouleen(self, nom, description, defaut):
self.pluginOptions.append(Option(Option.TYPE_BOULEEN, nom, description, defaut))
## Ajoute une option liste (choix multiple).
# @param self le plugin courant
# @param nom le nom de l'option (sert d'identifiant)
# @param description la description de l'option
# @param valeurs les valeurs possibles (liste)
# @param defauts les valeurs sélectionnées (liste)
# @return rien
def optionChoixMultiple(self, nom, description, defauts, valeurs):
self.pluginOptions.append(Option(Option.TYPE_CHOIX_MULTIPLE, nom, description, defauts, valeurs))
## Ajoute une option liste (choix unique).
# @param self le plugin courant
# @param nom le nom de l'option (sert d'identifiant)
# @param description la description de l'option
# @param valeurs les valeurs possibles (liste)
# @param defaut la valeur par défaut
# @return rien
def optionChoixUnique(self, nom, description, defaut, valeurs):
self.pluginOptions.append(Option(Option.TYPE_CHOIX_UNIQUE, nom, description, defaut, valeurs))
## Récupère une page web sur internet et remplace les caractères spéciaux (code HTML ou ISO).
# @param self le plugin courant
# @param url l'url de la page web
# @return la page web sous forme d'une chaîne ou la chaîne vide en cas d'échec
def getPage(self, url, data = None ):
return Plugin.NAVIGATEUR.getFile( url, data )
## Récupère des pages webs sur internet et remplace les caractères spéciaux (code HTML ou ISO).
# Cette méthode reste connecté au serveur si il y a plusieurs page à y télécharger,
# elle est plus rapide que plusieurs appel à getPage.
# @param self le plugin courant
# @param urls une liste d'url des pages à télécharger
# @return un dictionnaire avec comme clé les urls et comme valeur les pages sous forme de chaîne
def getPages(self, urls):
#FIXME Navigateur (téléchargement full threadé) vraiment efficace ?
reponses = Plugin.NAVIGATEUR.getFiles( urls )
return reponses
| Python |
#!/usr/bin/env python2
# -*- coding:Utf-8 -*-
# Adapted from :
# Brandon Thomson
# http://stackoverflow.com/questions/384076/how-can-i-make-the-python-logging-output-to-be-colored
import logging
class ColorFormatter( logging.Formatter ):
FORMAT = ( "[%(levelname)-19s] " "$BOLD%(filename)s$RESET:%(lineno)-5s" "%(message)s" )
BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)
RESET_SEQ = "\033[0m"
COLOR_SEQ = "\033[1;%dm"
BOLD_SEQ = "\033[1m"
COLORS = {
'WARNING' : YELLOW,
'INFO' : GREEN,
'DEBUG' : WHITE,
'CRITICAL' : RED,
'ERROR' : RED
}
def __init__( self, use_color ):
self.use_color = use_color
msg = self.formatter_msg( self.FORMAT )
logging.Formatter.__init__( self, msg )
def formatter_msg( self, msg ):
if( self.use_color ):
msg = msg.replace( "$RESET", self.RESET_SEQ ).replace( "$BOLD", self.BOLD_SEQ )
else:
msg = msg.replace( "$RESET", "" ).replace( "$BOLD", "" )
return msg
def format( self, record ):
levelname = record.levelname
if( self.use_color and levelname in self.COLORS ):
fore_color = 30 + self.COLORS[ levelname ]
levelname_color = self.COLOR_SEQ % fore_color + levelname + self.RESET_SEQ
record.levelname = levelname_color
return logging.Formatter.format( self, record )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
from lockfile import FileLock
import logging
logger = logging.getLogger( "TVDownloader" )
#import Constantes
import tvdcore
#{ Context de TVD.
# S'assure qu'aucun autre programme n'utilise actuellement le module de TVDownloader et instancie les plugins.
# Permet également de verrouiller les ressources qui doivent être libérées à la fin du programme
# et donne accès aux instances des classes principales de tvdcore.
class TVDContext(object):
__FILE_LOCK = FileLock(tvdcore.REPERTOIRE_CONFIGURATION)
## @var pluginManager
# L'instance du gestionnaire de plugins
## @var downloadManager
# L'instance du gestionnaire de téléchargements
## @var historique
# L'instance de l'historique
# Instance de la classe (singleton)
__instance = None
## Surcharge de la methode de construction standard (pour mettre en place le singleton)
def __new__(typ, *args, **kwargs):
if TVDContext.__instance == None:
#return super(object, typ).__new__(typ, *args, **kwargs)
return object.__new__(typ, *args, **kwargs)
else:
return TVDContext.__instance
def __init__(self, start=False) :
if TVDContext.__instance != None:
return
object.__init__(self)
TVDContext.__instance = self
self.initialized = False
self.downloadManager = None
self.pluginManager = None
self.historique = None
## Indique si le context est initialisé.
# A tester systématiquement avant d'éventuellement initialiser.
# @return True si oui, False sinon
def isInitialized(self):
return self.initialized
## Initialise le context et verrouille les ressources.
# Instancie les classes principales (les 3 attributs) si aucun programme n'utilise actuellement le module tvdcore.
# @return True en cas de réussite, False sinon
def initialize(self):
if TVDContext.__FILE_LOCK.is_locked():
logger.error("Une autre instance de TVDownloader ou un programme utilisant tvdcore est lancé")
return False
try:
TVDContext.__FILE_LOCK.acquire(20)
except Exception as e:
logger.error("Impossible de verrouiller les fichiers de configuration")
return False
self.initialized = True
self.downloadManager = tvdcore.DownloadManager()
self.pluginManager = tvdcore.PluginManager()
self.historique = tvdcore.Historique()
return True
## Libère les ressourses.
# Libère les fichiers de configuration de TVD pour le prochain lancement.
# Doit être appelée avant la fin du programme mais pas par les UIs.
def release(self):
try:
TVDContext.__FILE_LOCK.release()
except Exception as e:
logger.warn("Erreur de déverrouillage les fichiers de configuration")
return
self.initialized = False
self.downloadManager = None
self.pluginManager = None
self.historique = None
## Force la libération des ressourses.
# Libèration forcée des fichiers de configuration de TVD.
# Cela doit être utilisé uniquement dans le cas où les ressources
# sont verrouillées et où aucune instance de TVD n'est lancée.
def clean(self):
try:
TVDContext.__FILE_LOCK.break_lock()
except Exception as e:
logger.warn("Erreur de déverrouillage les fichiers de configuration")
return
| Python |
# -*- coding:Utf-8 -*-
from Downloaders import *
class AbstractDownloaderFactory :
def __init__(self) :
pass
def create (self, url) :
# returns DownloaderInterface
pass
## Fabrique concrète des DownloaderInterface
class DownloaderFactory (AbstractDownloaderFactory) :
def __init__(self) :
AbstractDownloaderFactory.__init__(self)
## Crée un DownloaderInterface
# @param url l'url du fichier à télécharger
# @return un DownloaderInterface permettant le téléchargement du fichier distant ou None si aucun compatible
def create (self, url) :
if FtpDownloader.canDownload(url):
return FtpDownloader(url)
elif HttpDownloader.canDownload(url):
return HttpDownloader(url)
elif MsdlDownloader.canDownload(url):
return MsdlDownloader(url)
elif RtmpDownloader.canDownload(url):
return RtmpDownloader(url)
else:
return None
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier LICENSE #
#########################################
#~ Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
#~ Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
#~ Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os.path
import pickle
import logging
logger = logging.getLogger( "TVDownloader" )
##########
# Classe #
##########
class Option():
def __init__(self, type, nom, description, valeur, choix=None):
self.type = type
self.nom= nom
self.description= description
self.valeur = valeur
if type == Option.TYPE_CHOIX_MULTIPLE and not isinstance(valeur, list):
raise Exception("La valeur doit être une liste pour le type spécifié.")
if choix != None:
if self.type != Option.TYPE_CHOIX_MULTIPLE and self.type != Option.TYPE_CHOIX_UNIQUE:
raise Exception("Liste des choix inutile pour le type d'option spécifié.")
elif not isinstance(choix, list):
raise Exception("La liste des choix doit être une liste.")
self.choix = choix
elif self.type == Option.TYPE_CHOIX_MULTIPLE or self.type == Option.TYPE_CHOIX_UNIQUE:
raise Exception("Liste des choix obligatoire pour le type d'option spécifié.")
#/*******************
# * CONSTANTES *
# *******************/
TYPE_TEXTE = "texte"
TYPE_BOULEEN = "bouleen"
TYPE_CHOIX_MULTIPLE = "choixmult"
TYPE_CHOIX_UNIQUE = "choixuniq"
def setValeur(self, valeur):
if self.type == Option.TYPE_TEXTE and not isinstance(valeur, str):
raise Exception("La valeur d'une option texte doit être une chaîne.")
elif self.type == Option.TYPE_BOULEEN and not isinstance(valeur, bool):
raise Exception("La valeur d'une option bouléen doit être un bouléen.")
elif self.type == Option.TYPE_CHOIX_MULTIPLE and not isinstance(valeur, list):
raise Exception("La valeur d'une option choix multiple doit être une liste.")
elif self.type == Option.TYPE_CHOIX_UNIQUE and not isinstance(valeur, str):
raise Exception("La valeur d'une option choix unique doit être une liste.")
self.valeur = valeur
def setChoix(self, choix):
if self.type == Option.TYPE_TEXTE:
raise Exception("Pas de choix pour les options de type texte.")
elif self.type == Option.TYPE_BOULEEN:
raise Exception("Pas de choix pour les options de type booléen.")
elif not isinstance(choix, list):
raise Exception("La liste des choix doit être une liste.")
self.choix = choix
def getType(self):
return self.type
def getNom(self):
return self.nom
def getDescription(self):
return self.description
def getValeur(self):
return self.valeur
def getChoix(self):
if self.type == Option.TYPE_TEXTE:
raise Exception("Pas de choix pour les options de type texte.")
elif self.type == Option.TYPE_BOULEEN:
raise Exception("Pas de choix pour les options de type booléen.")
return self.choix
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import httplib,re,zlib, os.path, time, pickle, traceback
from random import choice
from traceback import print_exc
import os
import sys
from Plugin import Plugin
import Constantes
import logging
logger = logging.getLogger( "TVDownloader" )
from util import Synchronized
import threading
from TVDContext import TVDContext
##########
# Classe #
##########
#TODO Fusion imcomplette, utiliser les setters dans le constructeur, gérer la liste
# des plugins présents, actifs et inactifs.
#TODO Avoir des timeouts sur les appels des méthodes des plugins
## Classe qui gere les plugins
class PluginManager( object ):
# Instance de la classe (singleton)
__instance = None
## Surcharge de la methode de construction standard (pour mettre en place le singleton)
def __new__(typ, *args, **kwargs):
# On vérifie qu'on peut instancier
context = TVDContext()
if not(context.isInitialized()):
logger.error("Le context n'est pas initialisé, impossible d'instancier")
return None
if PluginManager.__instance == None:
return super(PluginManager, typ).__new__(typ, *args, **kwargs)
else:
return PluginManager.__instance
## Constructeur
def __init__( self ):
if PluginManager.__instance != None:
return
PluginManager.__instance = self
#Code venant de APIPrive
self.listePluginActif = {}
self.listePlugin = {}
# Import de tous les plugins
for rep in Constantes.REPERTOIRES_PLUGINS:
# Ajout du repertoire au path si necessaire
if not( rep in sys.path ):
sys.path.insert( 0, rep )
# Verifie que le repertoire des plugins existe bien
if( not os.path.isdir( rep ) ):
logger.warn( "le repertoire %s des plugins n'existe pas..." %( rep ) )
else:
# Importe les plugins
self.importerPlugins( rep )
# Instancie les plugins
self.instancierPlugins()
self.callbacks = []
## Methode qui importe les plugins
# @param rep Repertoire dans lequel se trouvent les plugins a importer
@Synchronized
def importerPlugins( self, rep ):
for fichier in os.listdir( rep ):
# Tous les fichiers py autre que __init__.py sont des plugins a ajouter au programme
if( fichier [ -3 : ] == ".py" and fichier.find( "__init__.py" ) == -1 ):
# On suppose que c'est la derniere version du plugin
derniereVersion = True
# Pour les autres repertoires de plugins
for autreRep in ( set( Constantes.REPERTOIRES_PLUGINS ).difference( set( [ rep ] ) ) ):
if not os.path.isdir(autreRep):
continue
# Si le fichier existe dans l'autre repertoire
if( fichier in os.listdir( autreRep ) ):
# Si la version du plugin de l'autre repertoire est plus recente
if( os.stat( "%s/%s" %( autreRep, fichier ) ).st_mtime > os.stat( "%s/%s" %( rep, fichier ) ).st_mtime ):
derniereVersion = False
break # On arrete le parcourt des repertoires
# Si ce n'est pas la derniere version
if( not derniereVersion ):
continue # Fichier suivant
try :
__import__( fichier.replace( ".py", "" ), None, None, [ '' ] )
except ImportError as exc:
logger.error( "impossible d'importer le fichier %s: %s" %( fichier, exc.message ) )
traceback.print_exc()
continue
## Methode qui instancie les plugins
# N.B. : doit etre lancee apres importerPlugins
@Synchronized
def instancierPlugins( self ):
for plugin in Plugin.__subclasses__(): # Pour tous les plugins
try:
# Instance du plugin
inst = plugin()
except Exception as exc:
logger.error( "impossible d'instancier le plugin %s: %s" %( plugin, exc.message) )
traceback.print_exc()
continue
# Nom du plugin
# nom = inst.nom#FIXME Utiliser le nom de la classe
# Ajout du plugin
# self.listeInstances[ nom ] = inst
self.ajouterPlugin(inst)
## Methode qui retourne la liste des sites/plugins
# N.B. : doit etre lancee apres listerPlugins
# @return La liste des noms des plugins
# def getListeSites( self ):
# return self.listeInstances.keys()
## Methode qui retourne l'instance d'un plugin
# @param nom Nom du plugin dont il faut recuperer l'instance
# @return Instance du plugin ou None s'il n'existe pas
@Synchronized
def getInstance( self, nom ):
return self.listePlugin.get( nom, None )
@Synchronized
def addCallback( self, callback ):
self.callbacks.append(callback)
@Synchronized
def removeCallback( self, callback ):
self.callbacks.remove(callback)
###################################################
############# Code venant de APIPrive #############
###################################################
## Active un plugin (il faut qu'il ait déjà été ajouté).
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @return Rien
@Synchronized
def activerPlugin(self, nomPlugin):
if self.listePlugin.has_key(nomPlugin):
self.listePluginActif[nomPlugin] = self.listePlugin[nomPlugin]
for cback in self.callbacks:
cback.pluginStatus(nomPlugin, PluginStatus(PluginStatus.ENABLED))
## Désactive un plugin (il faut qu'il ait déjà été ajouté).
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @return Rien
@Synchronized
def desactiverPlugin(self, nomPlugin):
if self.listePluginActif.has_key(nomPlugin):
self.listePluginActif.pop(nomPlugin)
for cback in self.callbacks:
cback.pluginStatus(nomPlugin, PluginStatus(PluginStatus.DISABLED))
## Ajoute un plugin.
# @param self l'objet courant
# @param instance l'instance du plugin
# @return Rien
@Synchronized
def ajouterPlugin(self, instance):
if not self.listePlugin.has_key(instance.nom):#FIXME Utiliser le nom de la classe
self.listePluginActif[instance.nom] = instance
self.listePlugin[instance.nom] = instance#FIXME Utiliser le nom de la classe
instance.chargerCache()
## Spécifie la liste des instances des plugins.
# @param self l'objet courant
# @param liste la liste des instances
# @return Rien
# @deprecated Utiliser #ajouterPlugin à la place.
@Synchronized
def setListeInstance(self, liste):
logger.warn("DEPRECATED: APIPrive.setListeInstance: utilisez #ajouterPlugin")
self.listePluginActif = {}
for instance in liste:
self.ajouterPlugin(instance)
#/*******************
# * CONSTANTES *
# *******************/
DATA_CHAINE = "chaines"
DATA_EMISSION = "emissions"
DATA_FICHIER = "fichiers"
#/**************
# * GETTERS *
# **************/
## Renvoie la liste des plugins (leur nom)
# @param self l'objet courant
# @return la liste des noms des plugins
@Synchronized
def getPluginListe(self):
return self.listePlugin.keys()
## Renvoie la liste des plugins (leur instance)
# @return Liste des instances des plugins
@Synchronized
def getPluginListeInstances( self ):
return self.listePlugin.values()
## Renvoie la liste des plugins actifs (leur nom)
# @param self l'objet courant
# @return la liste des noms des plugins actifs
@Synchronized
def getPluginActifListe(self):
return self.listePluginActif.keys()
## Renvoie la liste des plugins inactifs (leur nom)
# @param self l'objet courant
# @return la liste des noms des plugins inactifs
@Synchronized
def getPluginInactifListe(self):
res = []
actifs = self.listePluginActif.keys()
for plugin in self.listePlugin.keys():
if not(plugin in actifs):
res.append(plugin)
return res
## Renvoie la liste des chaînes.
#
# Si nomPlugin est égal à None, la liste des chaînes de tout les plugins est renvoyée, sinon c'est celle du plugin portant le nom passé en paramètre.
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @return la liste des chaînes du plugin
@Synchronized
def getPluginListeChaines(self, nomPlugin=None):
if nomPlugin != None and not self.listePluginActif.has_key(nomPlugin):
return []
liste = []
if nomPlugin == None:
for nom in self.listePluginActif.keys():
plugin = self.listePluginActif[nom]
if len(plugin.pluginDatas[self.DATA_CHAINE]) == 0:
plugin.listerChaines()
liste+=plugin.pluginDatas[self.DATA_CHAINE]
else:
plugin = self.listePluginActif[nomPlugin]
if len(plugin.pluginDatas[self.DATA_CHAINE]) == 0:
plugin.listerChaines()
liste+=plugin.pluginDatas[self.DATA_CHAINE]
return liste
## Renvoie la liste des émissions pour un plugin et une chaîne donné.
#
# Si nomPlugin est égal à None, la liste des émissions de tout les plugins est renvoyée, sinon c'est celle du plugin portant le nom passé en paramètre. Si chaine est égal à None, la liste des émissions de toute les chaines du plugin est renvoyée.
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @param chaine le nom de la chaîne
# @return la liste des émissions
@Synchronized
def getPluginListeEmissions(self, nomPlugin=None, chaine=None):
if nomPlugin != None and not self.listePluginActif.has_key(nomPlugin):
return []
liste= []
if nomPlugin == None:
for nom in self.listePluginActif.keys():
plugin = self.listePluginActif[nom]
for chaine in self.getPluginListeChaines(nom):
if not plugin.pluginDatas[self.DATA_EMISSION].has_key(chaine):
plugin.pluginDatas[self.DATA_EMISSION][chaine] = []
plugin.listerEmissions(chaine)
liste+=plugin.pluginDatas[self.DATA_EMISSION][chaine]
elif chaine == None:
plugin = self.listePluginActif[nomPlugin]
for chaine in self.getPluginListeChaines(nomPlugin):
if not plugin.pluginDatas[self.DATA_EMISSION].has_key(chaine):
plugin.pluginDatas[self.DATA_EMISSION][chaine] = []
plugin.listerEmissions(chaine)
liste+=plugin.pluginDatas[self.DATA_EMISSION][chaine]
else:
plugin = self.listePluginActif[nomPlugin]
if not plugin.pluginDatas[self.DATA_EMISSION].has_key(chaine):
plugin.pluginDatas[self.DATA_EMISSION][chaine] = []
plugin.listerEmissions(chaine)
liste = plugin.pluginDatas[self.DATA_EMISSION][chaine]
return liste
## Renvoie la liste des fichiers pour un plugin et une émission donné
#
# Si nomPlugin est égal à None, la liste des fichiers de tout les plugins est renvoyée, sinon c'est celle du plugin portant le nom passé en paramètre. Si emission est égal à None, la liste des fichiers de toute les émissions du plugin est renvoyée.
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @param emission le nom de l'émission
# @return la liste des fichiers
@Synchronized
def getPluginListeFichiers(self, nomPlugin=None, emission=None):
if nomPlugin != None and not self.listePluginActif.has_key(nomPlugin):
return []
liste= []
if nomPlugin == None:
for nom in self.listePluginActif.keys():
plugin = self.listePluginActif[nom]
for emission in self.getPluginListeEmissions(nom):
if not plugin.pluginDatas[self.DATA_FICHIER].has_key(emission):
plugin.pluginDatas[self.DATA_FICHIER][emission] = []
plugin.listerFichiers(emission)
liste+=plugin.pluginDatas[self.DATA_FICHIER][emission]
elif emission == None:
plugin = self.listePluginActif[nomPlugin]
for emission in self.getPluginListeEmissions(nomPlugin):
if not plugin.pluginDatas[self.DATA_FICHIER].has_key(emission):
plugin.pluginDatas[self.DATA_FICHIER][emission] = []
plugin.listerFichiers(emission)
liste+=plugin.pluginDatas[self.DATA_FICHIER][emission]
else:
plugin = self.listePluginActif[nomPlugin]
if not plugin.pluginDatas[self.DATA_FICHIER].has_key(emission):
plugin.pluginDatas[self.DATA_FICHIER][emission] = []
plugin.listerFichiers(emission)
liste+=plugin.pluginDatas[self.DATA_FICHIER][emission]
return liste
## Renvoie la liste des options pour un plugin donné
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @return la liste des options
@Synchronized
def getPluginListeOptions(self, nomPlugin):
if not self.listePluginActif.has_key(nomPlugin):
return []
return self.listePluginActif[nomPlugin].pluginOptions
## Renvoie l'option d'un plugin
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @param nomOption le nom de l'option
# @return la valeur de l'option, None en cas d'échec
@Synchronized
def getPluginOption(self, nomPlugin, nomOption):
if nomPlugin != None and not self.listePluginActif.has_key(nomPlugin):
return None
plugin = self.listePluginActif[nomPlugin]
for option in plugin.pluginOptions:
if option.getNom() == nomOption:
return option
return None
#/**************
# * SETTERS *
# **************/
## Change la valeur d'une option d'un plugin.
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @param valeur la valeur de l'option
# @return Rien
@Synchronized
def setPluginOption(self, nomPlugin, nomOption, valeur):
if nomPlugin != None and not self.listePluginActif.has_key(nomPlugin):
return None
plugin = self.listePluginActif[nomPlugin]
plugin.pluginDatas = {"chaines":[],
"emissions":{},
"fichiers":{}}
for option in plugin.pluginOptions:
if option.getNom() == nomOption:
option.setValeur(valeur)
#/************
# * DIVERS *
# ************/
## Rafraichie un plugin (appel à Plugin.rafraichir)
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @return Rien
@Synchronized
def pluginRafraichir(self, nomPlugin):
logger.debug( "Rafraichissement du plugins %s" %( nomPlugin ) )
try:
if self.listePluginActif.has_key(nomPlugin):
for cback in self.callbacks:
cback.pluginStatus(nomPlugin, PluginStatus(PluginStatus.REFRESHING))
self.listePluginActif[nomPlugin].vider()
self.listePluginActif[nomPlugin].rafraichir()
for cback in self.callbacks:
cback.pluginStatus(nomPlugin, PluginStatus(PluginStatus.REFRESHED))
except Exception, ex:
logger.error("Erreur lors du rafraichissement du plugin",self.listePlugin[nomPlugin].nom+":"+str(ex))
print_exc()
except Error, er:
logger.error("Erreur lors du rafraichissement du plugin",self.listePlugin[nomPlugin].nom+":"+str(ex))
print_exc()
logger.debug( "Fin du rafraichissement du plugin %s" %( nomPlugin ) )
## Rafraichie tous les plugins qui ont besoin de l'être.
#
# Doit être appelé obligatoirement après l'ajout des plugins.
# @param self l'objet courant
# @return Rien
@Synchronized
def pluginRafraichirAuto(self):
t = time.time()
for instance in self.listePlugin.values():
if instance.frequence >= 0:
if os.path.isfile(instance.fichierCache):
delta = t-os.path.getmtime(instance.fichierCache)
if delta > instance.frequence*86400:
self.pluginRafraichir(instance.nom)
else:
self.pluginRafraichir(instance.nom)
#~ instance.chargerPreference()
#~ if len(instance.pluginOptions) == 0:
#~ instance.listerOptions()
instance.listerOptions()
if os.path.exists(instance.fichierConfiguration):
try:
file = open(instance.fichierConfiguration, "r")
tmp = pickle.load(file)
file.close()
for k in tmp.keys():
self.setPluginOption(instance.nom, k, tmp[k])
except:
logger.error( u"impossible de charger les préférences de %s" %( instance.nom ) )
## Effectue les tâches de sauvegarde avant la fermeture.
#
# Doit être absolument appelé avant la fermeture.
# @param self l'objet courant
@Synchronized
def fermeture(self):
for instance in self.listePlugin.values():
if len(instance.pluginOptions) > 0:
try:
pref = {}
for o in instance.pluginOptions:
pref[o.getNom()] = o.getValeur()
file = open(instance.fichierConfiguration, "w")
pickle.dump(pref, file)
file.close()
except:
logger.error("Erreur de sauvegarde des préférences de"+instance.nom)
class PluginCallback :
def __init__(self) :
pass
def pluginStatus(self, pluginName, status):
pass
class PluginStatus :
ENABLED = 0
DISABLED = 1
REFRESHING = 2
REFRESHED = 3
def __init__(self, status):
self.status = status
def getStatus(self):
return self.status
| Python |
# -*- coding:Utf-8 -*-
import thread,threading,traceback,time
from util import Synchronized,SynchronizedWith,CallbackGroup
from DownloaderFactory import *
from TVDContext import TVDContext
import logging
logger = logging.getLogger( "TVDownloader" )
dmlogger = logger
class DownloadManager(threading.Thread):
BUFFER_SIZE = 8000
# Instance de la classe (singleton)
__instance = None
## Surcharge de la methode de construction standard (pour mettre en place le singleton)
def __new__(typ, *args, **kwargs):
# On vérifie qu'on peut instancier
context = TVDContext()
if not(context.isInitialized()):
logger.error("Le context n'est pas initialisé, impossible d'instancier")
return None
if DownloadManager.__instance == None:#Décorateur ?
return super(DownloadManager, typ).__new__(typ, *args, **kwargs)
else:
return DownloadManager.__instance
def __init__(self, start=False) :
if DownloadManager.__instance != None:#Décorateur ?
return
threading.Thread.__init__(self)
DownloadManager.__instance = self
self.downloads = []
self.downloadsToStop = []
self.downloadsToPause = []
self.downloadsToResume = []
self.callbackGroup = CallbackGroup("downloadStatus")
self.maxDownloads = 3
self.maxSpeed = 0
self.stopped = False
self.nextNumDownload = 0
def getMaxDownloads(self):
return self.maxDownloads
def setMaxDownloads(self, maxDownloads):
self.maxDownloads = maxDownloads
def getMaxSpeed(self):
return self.maxSpeed
def setMaxSpeed(self, maxSpeed):
self.maxSpeed = maxSpeed
@Synchronized
def addDownloadCallback(self, callback):
self.callbackGroup.add(callback)
@Synchronized
def removeDownloadCallback(self, callback):
self.callbackGroup.remove(callback)
def start(self):
threading.Thread.start(self)
def stop(self):
self.stopped = True
@Synchronized
def pauseDownload(self, num):
self.downloadsToPause.append(num)
@Synchronized
def resumeDownload(self, num):
self.downloadsToResume.append(num)
@Synchronized
def stopDownload(self, num):
self.downloadsToStop.append(num)
@Synchronized
def getDownloads(self):
dls = []
for dl in self.downloads:
dls.append(
dl.getStatus()
)
return dls
@Synchronized
def getActiveDownloads(self):
res = []
for dl in self.downloads:
if dl.getStatus().status in [DownloadStatus.PAUSED, DownloadStatus.DOWN, DownloadStatus.QUEUED]:
res.append(dl.getNum())
return res
def run(self):
@SynchronizedWith(self)
def retrieveDls():
activeDls = []
for dl in self.downloads:
st = dl.getStatus().getStatus()
if st == DownloadStatus.DOWN or st == DownloadStatus.PAUSED:
#logger.debug("téléchargement actif: "+str(dl.getNum()))
activeDls.append(dl)
for newDl in self.downloads:
if len(activeDls) >= self.maxDownloads:
return activeDls
if newDl.getStatus().getStatus() != DownloadStatus.QUEUED:
continue
logger.debug("démarrage du téléchargement: "+str(newDl.getNum()))
newDl.start()
if newDl.getStatus().getStatus() == DownloadStatus.DOWN:
logger.debug("téléchargement en cours: "+str(newDl.getNum()))
activeDls.append(newDl)
else:
logger.warning("Echec de lancement du téléchargement "+str(newDl.getNum()))
newDl.getStatus().status = DownloadStatus.FAILED
self.callbackGroup(newDl.getStatus())
return activeDls
@SynchronizedWith(self)
def refreshStatuses():
for num in self.downloadsToStop:
stopDl(num)
for num in self.downloadsToPause:
pauseDl(num)
for num in self.downloadsToResume:
resumeDl(num)
@SynchronizedWith(self)
def stopDl(num):
for dl in self.downloads:
if dl.getStatus().getNum() == num:
if dl.isDownloading() or dl.isPaused():
logger.debug("arrêt téléchargement: "+str(dl.getNum()))
dl.interrupt()
elif dl.isQueued():
logger.debug("annulation téléchargement: "+str(dl.getNum()))
dl.cancel()
self.callbackGroup(dl.getStatus())
return
@SynchronizedWith(self)
def pauseDl(num):
for dl in self.downloads:
if dl.getStatus().getNum() == num:
logger.debug("pause téléchargement: "+str(dl.getNum()))
dl.pause()
self.callbackGroup(dl.getStatus())
return
@SynchronizedWith(self)
def resumeDl(num):
for dl in self.downloads:
if dl.getStatus().getNum() == num:
logger.debug("reprise téléchargement: "+str(dl.getNum()))
dl.resume()
self.callbackGroup(dl.getStatus())
return
pause = 0
while not(self.stopped):
dmlogger.debug("Téléchargement...")
activeDls = retrieveDls()
if len(activeDls) == 0:
dmlogger.debug("Pause, rien a dl")
time.sleep(0.5)#Utiliser les cond...
else:
for dl in activeDls:
if dl.isPaused():
dmlogger.debug("téléchargement en pause: "+str(dl.getNum()))
elif self.maxSpeed <= 0:
dmlogger.debug("step sur téléchargement: "+str(dl.getNum()))
dl.step()
self.callbackGroup(dl.getStatus())
else:
before = time.time()
success = dl.step()
after = time.time()
stepLength = dl.getLastStepLength()
dmlogger.debug("step sur téléchargement "+str(dl.getNum())+": "+str(stepLength))
if self.maxSpeed > 0:
stepDelta = (after-before)#Temps de téléchargement du step
stepSpeed = stepLength/stepDelta#Vitesse de téléchargement du step
stepMinDelta = (1.0*stepLength)/(1.0*self.maxSpeed)#Temps de téléchargement avec maxSpeed
pause = (stepMinDelta-stepDelta)#Ajout de la différence
dmlogger.debug("pause: "+str(pause))
if pause > 0:
time.sleep(pause)
self.callbackGroup(dl.getStatus())
#if self.maxSpeed > 0 and pause > 0:
# dmlogger.debug("pause: "+str(pause))
# time.sleep(pause)
# pause = 0
refreshStatuses()
#Arrêt de tout les téléchargements
for dl in self.downloads:
stopDl(dl.getStatus().getNum())
@Synchronized
def download (self, fichier) :
logger.debug("téléchargement "+str(self.nextNumDownload))
logger.debug(fichier.lien)
logger.debug(fichier.nomFichierSortie)
dl = Download(fichier, self.nextNumDownload)
self.downloads.append(dl)
self.callbackGroup(dl.getStatus())
res = self.nextNumDownload
self.nextNumDownload = self.nextNumDownload+1
return res
#TODO Différencier arrêt en cour et fin de dl
class Download :
STEP_SIZE = 32000
def __init__(self, fichier, num):
self.fichier = fichier
self.dler = fichier.getDownloader()
self.num = num
self.status = DownloadStatus(num, DownloadStatus.QUEUED, fichier.nom, 0)
self.outfile = None
self.lastStepLength = 0
def start(self):
if self.dler == None:
return False
try:
self.outfile = open(self.fichier.nomFichierSortie, "w")#TODO Dossier de téléchargement !!
except Exception:
self.status.status = DownloadStatus.FAILED
return False
if not(self.dler.start()):
self.outfile.close()
self.status.status = DownloadStatus.FAILED
return False
self.status.status = DownloadStatus.DOWN
self.status.size = self.dler.getSize()
return True
def interrupt(self):
self.outfile.close()
self.dler.stop()
if self.status.status != DownloadStatus.COMPLETED:
self.status.status = DownloadStatus.STOPPED
def isQueued(self):
return self.status.status == DownloadStatus.QUEUED
def isPaused(self):
return self.status.status == DownloadStatus.PAUSED
def isDownloading(self):
return self.status.status == DownloadStatus.DOWN
def pause(self):
if self.status.status == DownloadStatus.DOWN:
self.status.status = DownloadStatus.PAUSED
def cancel(self):
if self.status.status == DownloadStatus.QUEUED:
self.status.status = DownloadStatus.STOPPED
def resume(self):
if self.status.status == DownloadStatus.PAUSED:
self.status.status = DownloadStatus.DOWN
def getLastStepLength(self):
return self.lastStepLength
## Télécharge un bout du fichier.
# @return True si réussit, False en cas d'échec, None en cas de fin de flux
def step(self):
self.lastStepLength = 0
data = self.dler.read(Download.STEP_SIZE)
if data == None:
logger.debug("echec de step téléchargement "+str(self.num))
self.status.status = DownloadStatus.FAILED
return False
dled = len(data)
if dled == 0:
logger.debug("dernière step téléchargement "+str(self.num))
self.status.status = DownloadStatus.COMPLETED
historique = TVDContext().historique
if historique != None:
historique.ajouterHistorique(self.fichier)
else:
logger.warning("erreur d'ajout à l'historique du téléchargement "+str(self.num))
self.dler.stop()
return None
else:
self.lastStepLength = dled
logger.debug(str(dled)+" octets dans step téléchargement "+str(self.num))
self.status.status = DownloadStatus.DOWN
self.status.size = self.dler.getSize()
self.outfile.write(data)
self.status.downloaded = self.status.downloaded+dled
def getStatus(self):
return self.status
def getNum(self):
return self.status.getNum()
## Interface des callbacks de DownloaderManager;
#
# Un DownloadCallback est informé de l'état d'un téléchargement (progression, cas d'erreur) par le downloadManager. Voir DownloadManager.download.
class DownloadCallback :
def __init__(self) :
pass
## Appelée lors d'un changement de l'état d'un téléchargement.
# @param status le status d'un téléchargement (voir classe DownloadStatus)
def downloadStatus (self, status) :
# returns
pass
## Représente l'état d'un téléchargement
class DownloadStatus :
QUEUED = 0
PAUSED = 1
DOWN = 2
STOPPED = 3
FAILED = 4
COMPLETED = 5
## Constructeur
# @param num le numéro du téléchargement
# @param status l'état dans lequel se trouve le téléchargement
# (QUEUED,PAUSED,DOWN,STOPPED,FAILED,COMPLETED)
# @param name le nom du téléchargement (pour l'affichage)
# @param downloaded la taille des données téléchargées (en octet)
# @param size la taille en octet du fichier, None si inconnue
# @param name le nom du téléchargement (pour l'affichage)
def __init__(self, num, status, name, downloaded=0, size=None):
self.num = num
self.status = status
self.name = name
self.downloaded = downloaded
self.size = size
## Renvoie la taille des données téléchargées
# @return le nombre d'octets téléchargés
def getDownloaded(self):
return self.downloaded
## Renvoie la taille du fichier en cour de téléchargement.
# @return la taille en octet ou None si inconnue
def getSize(self):
return self.size
## Renvoie l'état dans lequel se trouve le téléchargement.
# @return l'état parmis QUEUED,PAUSED,DOWN,STOPPED,FAILED,COMPLETED
def getStatus(self):
return self.status
def getStatusText(self):
if self.status == DownloadStatus.QUEUED:
return "QUEUED"
elif self.status == DownloadStatus.PAUSED:
return "PAUSED"
elif self.status == DownloadStatus.DOWN:
return "DOWN"
elif self.status == DownloadStatus.STOPPED:
return "STOPPED"
elif self.status == DownloadStatus.FAILED:
return "FAILED"
elif self.status == DownloadStatus.COMPLETED:
return "COMPLETED"
else:
return "INVALIDE"
## Renvoie le nom du téléchargement, ce nom n'est pas unique et ne
# peut pas servir d'identifiant
# @return le nom du téléchargement
def getName(self):
return self.name
def getNum(self):
return self.num
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
from Constantes import *
from ColorFormatter import ColorFormatter
from DownloaderFactory import *
from Downloaders import *
from DownloadManager import *
from Historique import *
from Fichier import *
from Navigateur import *
from Option import *
from Plugin import *
from PluginManager import *
from TVDContext import *
import sys
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import re
import logging
logger = logging.getLogger( "TVDownloader" )
#############
# Fonctions #
#############
## Supprime les balises HTML d'une chaine de caracteres
# @param chaine Chaine a traiter
# @return Chaine traitee
def supprimeBalisesHTML( chaine ):
return re.sub( r'<.*?>', '', chaine )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import os
import unicodedata
import logging
logger = logging.getLogger( "TVDownloader" )
#############
# Fonctions #
#############
## Cree un repertoire s'il n'existe pas
# @param chemin Chemin du repertoire a creer
def verifieRepertoire( chemin ):
if( not os.path.exists( chemin ) ):
logger.info( "verifieRepertoire : le repertoire %s n'existe pas ; creation" %( chemin ) )
try :
os.makedirs( chemin )
except Exception, e :
logger.error( "verifieRepertoire : impossible de creer le dossier %s" %( chemin ) )
logger.error( e )
## Transforme une chaine de caracteres en chemin de fichier
# @param chaine Chaine de caracteres a traiter
# @return Chaine de caracteres utilisable comme nom de fichier
def chaineToNomFichier( chaine ):
if( isinstance( chaine, str ) ):
chaine = unicode( chaine, "utf8" )
# Supprime les accents
chaineNettoyee = unicodedata.normalize( 'NFKD', chaine ).encode( 'ASCII', 'ignore' )
# Supprimes les espaces
chaineSansEspaces = chaineNettoyee.replace( " ", "_" )
# Supprime les caracteres speciaux
return "".join( [ x for x in chaineSansEspaces if x.isalpha() or x.isdigit() or x == "." ] )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
##############
# Décorateur #
##############
import logging,threading
logger = logging.getLogger( "TVDownloader" )
## Décorateur qui permet d'assurer la synchronisation des méthodes, une
# thread à la fois travaille sur l'instance avec les méthodes marquées.
# L'instance doit posséder un attribut RLOCK affecté à une instance de
# threading.RLock. Ne peut décorer les méthodes __new__ ou __init__.
def SynchronizedMethod(meth):
logger.warning("Le décorateur SynchronizedMethod a été remplacée par Synchronized.")
return Synchronized(meth)
def local(self, *arg):
if hasattr(self, "RLOCK"):
self.RLOCK.acquire()
res = meth(self, *arg)
self.RLOCK.release()
else:
logger.error("Pas d'attribut RLOCK sur "+str(self))
res = meth(self, *arg)
return res
return local
def Synchronized(meth):
LOCAL_RLOCK = threading.RLock()
def local(self, *arg):
if not(hasattr(self, "RLOCK")):
LOCAL_RLOCK.acquire()
setattr(self, "RLOCK", threading.RLock())
LOCAL_RLOCK.release()
self.RLOCK.acquire()
res = meth(self, *arg)
self.RLOCK.release()
return res
return local
def SynchronizedWith(instance):
def decorator(func):
LOCAL_RLOCK = threading.RLock()
def local(*arg):
if not(hasattr(instance, "RLOCK")):
LOCAL_RLOCK.acquire()
setattr(instance, "RLOCK", threading.RLock())
LOCAL_RLOCK.release()
instance.RLOCK.acquire()
res = func(*arg)
instance.RLOCK.release()
return res
return local
return decorator
## Classe permettant la gestion d'un groupe de callback en gérant ajout,
# suppression et appel aux membres de ce groupe.
class CallbackGroup(object):
## Constructeur
# @param methode le nom de la méthode à appeler sur
# les callbacks
def __init__(self, methode):
self.callbacks = []
self.methode = methode
self.RLOCK = threading.RLock()
## Ajoute un callback à ce groupe.
# @param callback le callback
def add(self, callback):
self.callbacks.append(callback)
## Enlève un callback à ce groupe.
# @param callback le callback
def remove(self, callback):
self.callbacks.remove(callback)
## Appel les callbacks.
# @param args arguments à passer au callback
# @param kwargs arguments (keyword args) à passer au callback
def __call__(self, *args, **kwargs):
for cback in self.callbacks:
getattr(cback, self.methode)(*args, **kwargs)
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
# import os
import logging
logger = logging.getLogger( "TVDownloader" )
#############
# Fonctions #
#############
| Python |
#!/usr/bin/env python
# -*- encoding: UTF-8 -*-
import core,sys
if core.initialiser() != core.STATUS_INITIALIZED:
print "Erreur d'initialisation du module core"
sys.exit(1)
else:
print core.STATUS
import multiprocessing
from multiprocessing.managers import BaseManager
BaseManager.register('pluginManager', callable=lambda:core.PLUGIN_MANAGER)
BaseManager.register('downloadManager', callable=lambda:core.DOWNLOAD_MANAGER)
BaseManager.register('historique', callable=lambda:core.HISTORIQUE)
manager = BaseManager(core.SHARED_OBJECT_ADDRESS, core.SHARED_OBJECT_AUTHKEY)
server = manager.get_server()
print "Démon lancé..."
server.serve_forever()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtTableView( QtGui.QTableView ):
"""
Custom version of QTableView
"""
def __init__( self, parent = None ):
QtGui.QTableView.__init__( self, parent )
# No line number
self.verticalHeader().setVisible( False )
# No grid
self.setShowGrid( False )
# Always select only one line
self.setSelectionBehavior( QtGui.QAbstractItemView.SelectRows )
self.setSelectionMode( QtGui.QAbstractItemView.SingleSelection )
# Alternate colors
self.setAlternatingRowColors( True )
# Enable sorting
self.setSortingEnabled( True )
def resizeColumnsToContents( self ):
"""
Resize all columns
"""
QtGui.QTableView.resizeColumnsToContents( self )
if( not self.horizontalScrollBar().isVisible() ):
self.horizontalHeader().setStretchLastSection( True )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import threading
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Classe
#
class WaitWindow( QtGui.QProgressDialog ):
"""
Fenetre d'attente
"""
def __init__( self, parent = None ):
"""
Constructeur
"""
QtGui.QProgressDialog.__init__( self,
"Patientez pendant l'actualisation des informations de ",
"Fermer",
0,
0,
parent )
# La fenetre est modale
self.setModal( True )
# Titre de la fenetre
self.setWindowTitle( u"Merci de patienter..." )
# La fenetre ne peut pas changer de taille
self.setFixedSize( self.size() )
# Masque le bouton annuler
self.setCancelButton( None )
# Signal
QtCore.QObject.connect( self,
QtCore.SIGNAL( "ouvrirFenetre(PyQt_PyObject)" ),
self.ouvrirSiNecessaire )
# Etat dans lequel on veut que soit la fenetre
# N.B. : L'etat dans lequel on veut qu'elle soit n'est pas forcement l'etat dans lequel elle est
self.etatOuvert = False
# Mutex
self.mutex = threading.Lock()
def closeEvent( self, evenement ):
"""
La fenetre ne peut etre fermee que si elle est masquee
"""
# Si la fenetre est masquee
if( self.isHidden() ):
# Accept la fermeture
evenement.accept()
else:
# Refuse la fermeture
evenement.ignore()
def ouvrirFenetreAttente( self, nomSite ):
"""
Demande d'ouverture de la fenetre
Elle n'est reelement ouverte si necessaire qu'au bout d'un certain temps
"""
with self.mutex:
self.etatOuvert = True
# Attent un peu puis ouvre la fenetre si necessaire
threading.Timer( 0.5, self.emit, ( QtCore.SIGNAL( "ouvrirFenetre(PyQt_PyObject)" ), nomSite ) ).start()
def ouvrirSiNecessaire( self, nomSite ):
"""
Ouvre la fenetre d'attente (si c'est toujours necessaire
"""
with self.mutex:
if( self.etatOuvert ):
self.setLabelText( "Patientez pendant l'actualisation des informations de %s" %( nomSite ) )
self.show()
def fermerFenetreAttente( self ):
"""
Ferme la fenetre d'attente
"""
with self.mutex:
self.etatOuvert = False
if not ( self.isHidden() ):
self.hide()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import sys
import tvdcore
from PyQt4 import QtGui
from uis.qt.MainWindow import MainWindow
#
# Code
#
ctx = tvdcore.TVDContext()
if not( ctx.isInitialized() ) and not( ctx.initialize() ):
logger.error( "Impossible d'initialiser le context" )
else:
app = QtGui.QApplication( sys.argv )
window = MainWindow( "1.0" )
window.show()
print app.exec_()
# sys.exit( app.exec_() )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtTable( QtGui.QTableWidget ):
"""
Custom version of QTableWidget
"""
def __init__( self, parent = None ):
QtGui.QTableWidget.__init__( self, parent )
# No line number
self.verticalHeader().setVisible( False )
# No grid
self.setShowGrid( False )
# Always select only one line
self.setSelectionBehavior( QtGui.QAbstractItemView.SelectRows )
self.setSelectionMode( QtGui.QAbstractItemView.SingleSelection )
# Alternate colors
self.setAlternatingRowColors( True )
def resizeColumnsToContents( self ):
"""
Resize all columns
"""
QtGui.QTableWidget.resizeColumnsToContents( self )
if( not self.isHorizontalScrollBarVisible() ):
self.horizontalHeader().setStretchLastSection( True )
def clear( self ):
"""
Clear contents
"""
for i in range( self.rowCount() - 1, -1, -1 ): # [ nbLignes - 1, nbLignes - 2, ..., 1, 0 ]
self.removeRow( i )
self.resizeColumnsToContents()
def isHorizontalScrollBarVisible( self ):
"""
Is horizontal scroll bar visible ?
"""
isVisible = False
columnSize = 0
for i in range( self.columnCount() ):
columnSize += self.columnWidth( i )
widgetSize = self.width()
if( columnSize > widgetSize ):
isVisible = True
return isVisible
def createItem( self, text, editable = False, checkBox = False, checked = False ):
"""
Return a new item for QtTable
"""
item = QtGui.QTableWidgetItem( stringToQstring( text ) )
item.setTextAlignment( QtCore.Qt.AlignCenter )
if( not editable ):
item.setFlags( item.flags() & ~QtCore.Qt.ItemIsEditable )
if( checkBox ):
if( checked ):
item.setCheckState( QtCore.Qt.Checked )
else:
item.setCheckState( QtCore.Qt.Unchecked )
return item
def getLine( self, row ):
"""
Get a line (use it with setLine)
"""
line = []
for i in range( self.columnCount() ):
line.append( self.takeItem( row, i ) )
return line
def copyLine( self, row ):
"""
Get a line (use it with setLine)
"""
line = []
for i in range( self.columnCount() ):
line.append( self.item( row, i ).clone() )
return line
def setLine( self, row, line ):
"""
Set a line (use it with getLine and copyLine)
"""
columnNum = self.columnCount()
if( len( line ) == columnNum ):
for i in range( columnNum ):
self.setItem( row, i, line[ i ] )
def swapLines( self, row1, row2 ):
"""
Swap two lines
"""
if( row1 != row2 ):
line1 = self.getLine( row1 )
self.setLine( row1, self.getLine( row2 ) )
self.setLine( row2, line1 )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Classe
#
class TelechargementsTableModel( QtCore.QAbstractTableModel ):
"""
Model pour afficher la liste des telechargements
"""
def __init__( self, listeStatus = [], parent = None ):
QtCore.QAbstractTableModel.__init__( self, parent )
self.listeStatus = listeStatus
self.header = [ "Nom", "Avancement", "Reçu", "Etat" ]
def changeStatus( self, status ):
"""
Ajoute ou met a jour le status d'un telechargement
"""
if( status not in self.listeStatus ):
self.beginInsertRows( QtCore.QModelIndex(), len( self.listeStatus ), len( self.listeStatus ) )
self.listeStatus.append( status )
self.endInsertRows()
else:
self.listeStatus[ self.listeStatus.index( status ) ] = status
indexTopLeft = self.index( self.listeStatus.index( status ), 0 )
indexBottomRight = self.index( self.listeStatus.index( status ), len( self.header ) - 1 )
self.emit( QtCore.SIGNAL( "dataChanged(const QModelIndex &, const QModelIndex &)" ), indexTopLeft, indexBottomRight )
def clearList( self ):
"""
Supprime de la liste les telechargements termines
"""
for i in range( len( self.listeStatus ) - 1, -1, -1 ):
if( self.listeStatus[ i ].getStatusText() == "COMPLETED" ):
self.beginRemoveRows( QtCore.QModelIndex(), i, i )
del self.listeStatus[ i ]
self.endRemoveRows()
def removeDownload( self, index ):
"""
Supprime un telechargement
"""
if( index != -1 ):
self.beginRemoveRows( QtCore.QModelIndex(), index, index )
del self.listeStatus[ index ]
self.endRemoveRows()
def rowCount( self, parent ):
return len( self.listeStatus )
def columnCount( self, parent ):
return len( self.header )
def headerData( self, section, orientation, role ):
if( orientation == QtCore.Qt.Horizontal and role == QtCore.Qt.DisplayRole ):
return QtCore.QVariant( stringToQstring( self.header[ section ] ) )
return QtCore.QVariant()
def data( self, index, role ):
if( not index.isValid() ):
return QtCore.QVariant()
elif( role == QtCore.Qt.BackgroundRole ):
if( index.row() % 2 == 0 ):
return QtGui.QColor( QtCore.Qt.white )
else:
return QtGui.QColor( QtCore.Qt.lightGray )
elif( role == QtCore.Qt.DisplayRole ):
if( index.column() == 0 ): # Nom
return QtCore.QVariant( stringToQstring( self.listeStatus[ index.row() ].name ) )
elif( index.column() == 1 ): # Avancement
taille = self.listeStatus[ index.row() ].downloaded
tailleTotale = self.listeStatus[ index.row() ].size
if( tailleTotale is None or tailleTotale <= 0 ):
pourcent = "???"
else:
pourcent = "%.2f %%" %( 100 * taille / float( tailleTotale ) )
return QtCore.QVariant( stringToQstring( pourcent ) )
elif( index.column() == 2 ): # Recu
taille = self.listeStatus[ index.row() ].downloaded
if( taille < 1024 ):
tailleString = "%.2f o" %( taille )
elif( taille < 1024 * 1024 ):
tailleString = "%.2f Kio" %( taille / 1024.0 )
else:
tailleString = "%.2f Mio" %( taille / ( 1024.0 * 1024.0 ) )
return QtCore.QVariant( stringToQstring( tailleString ) )
elif( index.column() == 3 ): # Etat
return QtCore.QVariant( stringToQstring( self.listeStatus[ index.row() ].getStatusText().title() ) )
else:
return QtCore.QVariant()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import datetime
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Classe
#
class FichiersTableModel( QtCore.QAbstractTableModel ):
"""
Model pour afficher la liste des fichiers
"""
def __init__( self, listeFichiers = [], parent = None ):
QtCore.QAbstractTableModel.__init__( self, parent )
self.listeFichiers = listeFichiers
self.header = [ "", "Date", "Emission" ]
def changeFiles( self, listeFichiers ):
self.listeFichiers = listeFichiers
self.reset()
def rowCount( self, parent ):
return len( self.listeFichiers )
def columnCount( self, parent ):
return len( self.header )
def sort( self, column, order ):
# Never sort first column
if( column == 0 ):
return
# Order
reverse = False
if( order == QtCore.Qt.DescendingOrder ):
reverse = True
# Sort function
if( column == 1 ):
sortFnct = lambda x : x.date
else:
sortFnct = lambda x : x.nom
# Sort
self.emit( QtCore.SIGNAL( "layoutAboutToBeChanged()" ) )
self.listeFichiers.sort( key = sortFnct, reverse = reverse )
self.emit( QtCore.SIGNAL( "layoutChanged()" ) )
def headerData( self, section, orientation, role ):
if( orientation == QtCore.Qt.Horizontal and role == QtCore.Qt.DisplayRole ):
return QtCore.QVariant( self.header[ section ] )
return QtCore.QVariant()
def data( self, index, role ):
if( not index.isValid() ):
return QtCore.QVariant()
elif( role == QtCore.Qt.BackgroundRole ):
if( index.row() % 2 == 0 ):
return QtGui.QColor( QtCore.Qt.white )
else:
return QtGui.QColor( QtCore.Qt.lightGray )
elif( role == QtCore.Qt.DisplayRole ):
if( index.column() == 0 ):
return QtCore.QVariant( "" )
elif( index.column() == 1 ):
date = self.listeFichiers[ index.row() ].date
if( isinstance( date, datetime.date ) ):
dateOk = date.strftime( "%a %d %b" )
else:
dateOk = date
return QtCore.QVariant( stringToQstring( dateOk ) )
else:
return QtCore.QVariant( stringToQstring( self.listeFichiers[ index.row() ].nom ) )
else:
return QtCore.QVariant()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtProgressBarDelegate( QtGui.QItemDelegate ):
"""
Delegate for a QProgressBar
"""
def __init__( self, parent = None ):
QtGui.QItemDelegate.__init__( self, parent )
self.percent = 0
def paint( self, painter, option, index ):
"""
"""
opts = QtGui.QStyleOptionProgressBarV2()
opts.rect = option.rect
opts.minimum = 1
opts.maximum = 100
opts.progress = self.percent
opts.textVisible = True
opts.text = QtCore.QString( "%d%%" %( self.percent ) )
QtGui.QApplication.style().drawControl( QtGui.QStyle.CE_ProgressBar, opts, painter )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtIconsList( QtGui.QScrollArea ):
"""
Widget to display a list of icons (QIcon)
"""
iconsSize = QtCore.QSize( 100, 30 )
def __init__( self, parent = None ):
QtGui.QScrollArea.__init__( self )
self.setWidgetResizable( True )
self.setHorizontalScrollBarPolicy( QtCore.Qt.ScrollBarAlwaysOff )
self.setMinimumHeight( 125 )
self.setMinimumWidth( 150 )
# Widget
self.widget = QtGui.QWidget( parent )
self.setWidget( self.widget )
# Vertical layout
self.layout = QtGui.QVBoxLayout( self.widget )
# Array to store icons names
self.buttonsNames = []
# Button group
self.buttonGroup = QtGui.QButtonGroup( self.widget )
self.buttonGroup.setExclusive( True )
QtCore.QObject.connect( self.buttonGroup,
QtCore.SIGNAL( "buttonClicked(int)" ),
self.buttonClicked )
def clear( self ):
"""
Clear icons list
"""
self.buttonsNames = []
for button in self.buttonGroup.buttons():
self.buttonGroup.removeButton( button )
self.layout.removeWidget( button )
button.close()
def addIcon( self, name, icon = None ):
"""
Add an icon to the list
icon must be a QIcon
"""
if( icon ):
button = QtGui.QPushButton( icon, "", self.widget )
button.setIconSize( self.iconsSize )
else:
button = QtGui.QPushButton( stringToQstring( name ), self.widget )
button.setFlat( True )
button.setCheckable( True )
button.setToolTip( stringToQstring( name ) )
self.layout.addWidget( button )
self.buttonsNames.append( name )
self.buttonGroup.addButton( button, len( self.buttonsNames ) - 1 )
def buttonClicked( self, buttonId ):
"""
When a button is clicked, a signal is emitted with button name
"""
self.emit( QtCore.SIGNAL( "buttonClicked(PyQt_PyObject)" ), self.buttonsNames[ buttonId ] )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import logging
logger = logging.getLogger( "TVDownloader" )
import os
import operator
import threading
import sys
sys.path.append( ".." )
import tvdcore
from base.Browser import Browser
from base.qt.QtFolderChooser import QtFolderChooser
from base.qt.qtString import qstringToString
from base.qt.qtString import stringToQstring
from core.Configuration import Configuration
import core.Constantes as Constantes
from core.DownloadManager import DownloadCallback
from PyQt4 import QtCore
from PyQt4 import QtGui
from uis.qt.QtIconsList import QtIconsList
from uis.qt.QtTable import QtTable
from uis.qt.QtTableView import QtTableView
from uis.qt.QtProgressBarDelegate import QtProgressBarDelegate
from uis.qt.WaitWindow import WaitWindow
from uis.qt.models.FichiersTableModel import FichiersTableModel
from uis.qt.models.TelechargementsTableModel import TelechargementsTableModel
#
# Classes
#
class MainWindow( QtGui.QMainWindow ):
"""
TVDownloader MainWindows
"""
def __init__( self, tvdVersion ):
"""
Constructeur
"""
# Appel au constructeur de la classe mere
QtGui.QMainWindow.__init__( self )
#
# Fonts
#
# Font pour les titres
self.titreFont = QtGui.QFont()
self.titreFont.setPointSize( 11 )
self.titreFont.setWeight( 75 )
self.titreFont.setBold( True )
#
# Icones
#
self.tvdIco = QtGui.QIcon( "uis/qt/ico/TVDownloader.png" )
self.folderIco = QtGui.QIcon( "uis/qt/ico/gtk-folder.svg" )
self.startIco = QtGui.QIcon( "uis/qt/ico/gtk-media-play-ltr.svg" )
self.settingsIco = QtGui.QIcon( "uis/qt/ico/gtk-preferences.svg" )
self.fileIco = QtGui.QIcon( "uis/qt/ico/gtk-file.svg" )
self.downloadIco = QtGui.QIcon( "uis/qt/ico/fr_stock_add.svg" )
self.pauseIco = QtGui.QIcon( "uis/qt/ico/gtk-media-pause.svg" )
self.cancelIco = QtGui.QIcon( "uis/qt/ico/gtk-cancel.svg" )
self.deleteIco = QtGui.QIcon( "uis/qt/ico/gtk-delete-full.svg" )
#
# Signaux
#
# Liste des plugins a mettre en place
self.listePluginsSignal = QtCore.SIGNAL( "listePlugins(PyQt_PyObject)" )
QtCore.QObject.connect( self, self.listePluginsSignal, self.ajouterPlugins )
# Liste des chaines a mettre en place
self.listeChainesSignal = QtCore.SIGNAL( "listeChaines(PyQt_PyObject)" )
QtCore.QObject.connect( self, self.listeChainesSignal, self.ajouterChaines )
# Liste des emissions a mettre en place
self.listeEmissionsSignal = QtCore.SIGNAL( "listeEmission(PyQt_PyObject)" )
QtCore.QObject.connect( self, self.listeEmissionsSignal, self.ajouterEmissions )
# Liste des fichiers a mettre en place
self.listeFichiersSignal = QtCore.SIGNAL( "listeFichiers(PyQt_PyObject)" )
QtCore.QObject.connect( self, self.listeFichiersSignal, self.ajouterFichiers )
# Affiche une nouvelle image de description
self.nouvelleImageDescriptionSignal = QtCore.SIGNAL( "nouvelleImageDescription(PyQt_PyObject)" )
QtCore.QObject.connect( self, self.nouvelleImageDescriptionSignal, self.afficherImageDescription )
#
# Reglages de la fenetre
#
# Nom de la fenetre
self.setWindowTitle( "%s %s" %( Constantes.TVD_NOM, Constantes.TVD_VERSION ) )
# Mise en place de son icone
self.setWindowIcon( self.tvdIco )
#
# Widget central de la fenetre
#
# Widget central qui contiendra tout
self.centralWidget = QtGui.QWidget( self )
self.setCentralWidget( self.centralWidget )
# Layout de grille pour le widget central
self.centralGridLayout = QtGui.QGridLayout( self.centralWidget )
#
# Onglets
#
# Gestionnaire onglets
self.tabWidget = QtGui.QTabWidget( self.centralWidget )
self.centralGridLayout.addWidget( self.tabWidget, 0, 0, 1, 2 )
# Onglet Fichiers
self.fichiersWidget = QtGui.QSplitter( QtCore.Qt.Vertical, self.centralWidget )
self.tabWidget.addTab( self.fichiersWidget, self.fileIco, u"Choix des fichiers" )
# Onglet Telechargements
self.telechargementsWidget = QtTableView( self.centralWidget )
self.tabWidget.addTab( self.telechargementsWidget, self.downloadIco, u"Téléchargements" )
# Onglet Parametres
self.parametresWidget = QtGui.QWidget( self.centralWidget )
self.tabWidget.addTab( self.parametresWidget, self.settingsIco, u"Paramètres" )
#
# Onglet Fichiers
#
# Widget choix fichiers
self.choixFichiersWidget = QtGui.QSplitter( QtCore.Qt.Horizontal, self.fichiersWidget )
self.fichiersWidget.addWidget( self.choixFichiersWidget )
# Widget choix de la chaine
self.chaineWidget = QtGui.QWidget( self.choixFichiersWidget )
self.choixFichiersWidget.addWidget( self.chaineWidget )
# Layout chaine
self.chaineLayout = QtGui.QVBoxLayout( self.chaineWidget )
# Choix du plugin
self.pluginComboBox = QtGui.QComboBox( self.chaineWidget )
QtCore.QObject.connect( self.pluginComboBox,
QtCore.SIGNAL( "activated(QString)" ),
self.listerChaines )
self.chaineLayout.addWidget( self.pluginComboBox )
# Liste des chaines
self.chaineIconsList = QtIconsList( self.chaineWidget )
QtCore.QObject.connect( self.chaineIconsList,
QtCore.SIGNAL( "buttonClicked(PyQt_PyObject)" ),
self.listerEmissions )
self.chaineLayout.addWidget( self.chaineIconsList )
# Widget choix des fichiers
self.fichierWidget = QtGui.QWidget( self.choixFichiersWidget )
self.choixFichiersWidget.addWidget( self.fichierWidget )
# Layout fichiers
self.fichierLayout = QtGui.QVBoxLayout( self.fichierWidget )
# Choix de l'emission
self.emissionComboBox = QtGui.QComboBox( self.fichierWidget )
QtCore.QObject.connect( self.emissionComboBox,
QtCore.SIGNAL( "activated(QString)" ),
self.listerFichiers )
self.fichierLayout.addWidget( self.emissionComboBox )
# Liste des fichiers
self.fichierTableView = QtTableView( self.fichierWidget )
fichierTableModel = FichiersTableModel()
self.fichierTableView.setModel( fichierTableModel )
self.fichierLayout.addWidget( self.fichierTableView )
QtCore.QObject.connect( self.fichierTableView.selectionModel(),
QtCore.SIGNAL( "selectionChanged(const QItemSelection &, const QItemSelection &)" ),
self.afficherDescriptionFichier )
QtCore.QObject.connect( self.fichierTableView,
QtCore.SIGNAL( "doubleClicked(const QModelIndex &)" ),
self.ajouterTelechargement)
# Widget descriptif fichier
self.descriptifFichierWidget = QtGui.QSplitter( QtCore.Qt.Horizontal, self.fichiersWidget )
self.fichiersWidget.addWidget( self.descriptifFichierWidget )
# Label du fichier
self.fichierLabel = QtGui.QLabel( self.descriptifFichierWidget )
self.descriptifFichierWidget.addWidget( self.fichierLabel )
# Logo par defaut
self.logoDefautPixmap = QtGui.QPixmap()
self.logoDefautPixmap.load( "uis/qt/ico/gtk-dialog-question.svg" )
self.afficherImageDescription( self.logoDefautPixmap )
# Descriptif du fichier
self.descriptionPlainTextEdit = QtGui.QPlainTextEdit( self.descriptifFichierWidget )
self.descriptifFichierWidget.addWidget( self.descriptionPlainTextEdit )
#
# Onglet Telechargements
#
# Liste des telechargements
telechargementsTableModel = TelechargementsTableModel()
self.telechargementsWidget.setModel( telechargementsTableModel )
# self.telechargementsWidget.setItemDelegateForColumn( 1, QtProgressBarDelegate() )
# Menu clic droit sur la liste des telechargements
self.telechargementsWidget.setContextMenuPolicy( QtCore.Qt.ActionsContextMenu )
# self.telechargementsWidget.addAction( QtGui.QAction( self.pauseIco, stringToQstring( "Suspendre le téléchargement" ), self.telechargementsWidget ) )
# self.telechargementsWidget.addAction( QtGui.QAction( self.startIco, stringToQstring( "Reprendre le téléchargement" ), self.telechargementsWidget ) )
# Action pour annuler un telechargement
cancelAction = QtGui.QAction( self.cancelIco, stringToQstring( "Annuler le téléchargement" ), self.telechargementsWidget )
self.telechargementsWidget.addAction( cancelAction )
QtCore.QObject.connect( cancelAction,
QtCore.SIGNAL( "triggered()" ),
self.supprimerTelechargement )
# Action pour effacer les telechargement termines de la liste
clearListAction = QtGui.QAction( self.deleteIco, stringToQstring( "Effacer les téléchargements terminées de la liste" ), self.telechargementsWidget )
self.telechargementsWidget.addAction( clearListAction )
QtCore.QObject.connect( clearListAction,
QtCore.SIGNAL( "triggered()" ),
telechargementsTableModel.clearList )
#
# Onglet Parametres
#
# Layout de forumlaire
self.parametresLayout = QtGui.QFormLayout( self.parametresWidget )
# Titre Repertoire
self.titreRepertoireLabel = QtGui.QLabel( self.parametresWidget )
self.titreRepertoireLabel.setFont( self.titreFont )
self.titreRepertoireLabel.setText( u"Répertoires :" )
self.parametresLayout.addRow( self.titreRepertoireLabel, None )
# Repertoire par defaut pour les videos
self.choixRepertoire = QtFolderChooser( self.parametresWidget, self.folderIco )
QtCore.QObject.connect( self.choixRepertoire,
QtCore.SIGNAL( "valueChanged(PyQt_PyObject)" ),
lambda valeur : self.enregistrerConfiguration( Configuration.TVD_REPERTOIRE_TELECHARGEMENT, valeur ) )
self.parametresLayout.addRow( u"Répertoire de téléchargement :", self.choixRepertoire )
# Titre Internet
self.titreInternetLabel = QtGui.QLabel( self.parametresWidget )
self.titreInternetLabel.setFont( self.titreFont )
self.titreInternetLabel.setText( u"Paramètres Internet :" )
self.parametresLayout.addRow( self.titreInternetLabel, None )
# Time out du navigateur
self.timeOutSpinBox = QtGui.QSpinBox( self.parametresWidget )
self.timeOutSpinBox.setMinimum( 1 )
self.timeOutSpinBox.setMaximum( 60 )
QtCore.QObject.connect( self.timeOutSpinBox,
QtCore.SIGNAL( "valueChanged(int)" ),
lambda valeur : self.enregistrerConfiguration( Configuration.NAVIGATEUR_TIMEOUT, str( valeur ) ) )
self.parametresLayout.addRow( u"Time out (en s) :", self.timeOutSpinBox )
# Nombre de threads du navigateur
self.threadSpinBox = QtGui.QSpinBox( self.parametresWidget )
self.threadSpinBox.setMinimum( 1 )
self.threadSpinBox.setMaximum( 100 )
QtCore.QObject.connect( self.threadSpinBox,
QtCore.SIGNAL( "valueChanged(int)" ),
lambda valeur : self.enregistrerConfiguration( Configuration.NAVIGATEUR_THREADS, str( valeur ) ) )
self.parametresLayout.addRow( u"Nombre de threads max :", self.threadSpinBox )
#
# Descriptif des fichiers
#
#
# Barres de progression
#
# self.dlFichierProgressBar = QtGui.QProgressBar( self.centralWidget )
# self.dlFichierProgressBar.setProperty( "value", 0 )
# self.centralGridLayout.addWidget( self.dlFichierProgressBar, 2, 0, 1, 2 )
# self.dlProgressBar = QtGui.QProgressBar( self.centralWidget )
# self.dlProgressBar.setProperty( "value", 0 )
# self.centralGridLayout.addWidget( self.dlProgressBar, 3, 0, 1, 2 )
#
# Bouton de téléchargement
#
# self.lancerPushButton = QtGui.QPushButton( self.startIco, u"Lancer téléchargement", self.centralWidget )
# self.centralGridLayout.addWidget( self.lancerPushButton, 4, 0, 1, 2 )
#
# Autre
#
# Instancie la fenetre d'attente
self.fenetreAttente = WaitWindow( self )
QtCore.QObject.connect( self,
QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ),
self.fenetreAttente.ouvrirFenetreAttente )
QtCore.QObject.connect( self,
QtCore.SIGNAL( "finActualisation()" ),
self.fenetreAttente.fermerFenetreAttente )
#
# Debut
#
self.actionsAuDebut()
def closeEvent( self, evt ):
"""
Surcharge de la methode appele lors de la fermeture de la fenetre
"""
self.actionsAvantQuitter()
evt.accept()
def actionsAuDebut( self ):
"""
Actions a realiser au demarage du programe
"""
# Recupere l'instance de TVDContext
self.tvdContext = tvdcore.TVDContext()
# Recupere les instances des classes utiles
self.pluginManager = self.tvdContext.pluginManager
self.downloadManager = self.tvdContext.downloadManager
self.navigateur = Browser()
# Variables
# Ajout une callback pour le download manager
self.telechargementsCallback = TelechargementsCallback( self.telechargementsWidget )
self.downloadManager.addDownloadCallback( self.telechargementsCallback )
# Demarre le download manager
self.downloadManager.start()
# Lance l'actualisation des plugins
self.rafraichirTousLesPlugins()
#
# A deplacer
#
self.config = Configuration()
self.afficherConfiguration()
def actionsAvantQuitter( self ):
"""
Actions a realiser avant de quitter le programme
"""
self.config.save()
# Supprime la callback
self.downloadManager.removeDownloadCallback( self.telechargementsCallback )
# Stoppe le download manager
self.downloadManager.stop()
print "Bye bye"
def rafraichirTousLesPlugins( self ):
"""
Lance le rafraichissement de tous les plugins (si necessaire)
"""
def threadRafraichirPlugins( self ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), "tous les plugins" )
try:
self.pluginManager.pluginRafraichirAuto()
except:
logger.error( "impossible de rafraichir un des plugins" )
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
self.listerPlugins()
threading.Thread( target = threadRafraichirPlugins, args = ( self, ) ).start()
def listerPlugins( self ):
"""
Fonction qui demande la liste des plugins
"""
def threadListerPlugins( self ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), "tous les plugins" )
try:
listePlugins = self.pluginManager.getPluginListe()
except:
listePlugins = []
logger.error( "impossible de récuperer la liste des plugins" )
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
self.emit( self.listePluginsSignal, listePlugins )
threading.Thread( target = threadListerPlugins, args = ( self, ) ).start()
def listerChaines( self, plugin = None ):
"""
Fonction qui demande la liste des chaines d'un plugin donne
Si plugin = None, alors elle demande la liste des chaines de tous les plugins
"""
def threadListerChaines( self, plugin ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), plugin )
try:
listeChaines = self.pluginManager.getPluginListeChaines( plugin )
except:
listeChaines = []
logger.error( "impossible de récuperer les chaines de %s" %( plugin ) )
listeImagesUrl = [ x[ 1 ] for x in listeChaines ]
# Charge les images
listeImages = self.navigateur.getFiles( listeImagesUrl )
# Creer la liste avec les images
listeChainesAvecImage = []
for ( nom, urlImage ) in listeChaines:
if( listeImages.has_key( urlImage ) ):
image = listeImages[ urlImage ]
else:
image = None
listeChainesAvecImage.append( ( nom, image ) )
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
self.emit( self.listeChainesSignal, listeChainesAvecImage )
if( plugin ):
plugin = qstringToString( plugin )
threading.Thread( target = threadListerChaines, args = ( self, plugin ) ).start()
def listerEmissions( self, chaine ):
"""
Fonction qui demande la liste des emissions d'une chaine donnee
"""
def threadListerEmissions( self, plugin, chaine ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), plugin )
try:
listeEmissions = self.pluginManager.getPluginListeEmissions( plugin, chaine )
except:
listeEmissions = []
logger.error( "impossible de récuperer la liste des emissions de %s (%s)" %( chaine, plugin ) )
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
self.emit( self.listeEmissionsSignal, listeEmissions )
plugin = qstringToString( self.pluginComboBox.currentText() )
threading.Thread( target = threadListerEmissions, args = ( self, plugin, chaine ) ).start()
def listerFichiers( self, emission ):
"""
Fonction qui demande la liste des fichiers d'une emission donnee
"""
def threadListerFichiers( self, plugin, emission ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), plugin )
try:
listeFichiers = self.pluginManager.getPluginListeFichiers( plugin, emission )
except:
listeFichiers = []
logger.error( "impossible de récuperer la liste des fichiers de %s (%s)" %( emission, plugin ) )
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
self.emit( self.listeFichiersSignal, listeFichiers )
plugin = qstringToString( self.pluginComboBox.currentText() )
threading.Thread( target = threadListerFichiers, args = ( self, plugin, qstringToString( emission ) ) ).start()
def ajouterPlugins( self, listePlugins ):
"""
Met en place la liste des plugins donnee
"""
listePlugins.sort()
self.nettoyerWidgets( plugins = True, chaines = True, emissions = True, fichiers = True, description = True )
map( lambda x : self.pluginComboBox.addItem( stringToQstring( x ) ), listePlugins )
# S'il n'y a qu'un seul plugin
if( self.pluginComboBox.count() == 1 ):
# Lance le listage des chaines
self.listerChaines( self.pluginComboBox.currentText() )
else:
# Ne selectionne pas le plugin
self.pluginComboBox.setCurrentIndex( -1 )
def ajouterChaines( self, listeChaines ):
"""
Met en place la liste des chaines donnee sous la forme ( nomChaine, logoChaine )
"""
listeChaines = sorted( listeChaines, key = operator.itemgetter( 0 ) )
self.nettoyerWidgets( plugins = False, chaines = True, emissions = True, fichiers = True, description = True )
for ( nom, imageData ) in listeChaines:
if( imageData is None ):
self.chaineIconsList.addIcon( nom, None )
else:
image = QtGui.QImage()
image.loadFromData( imageData )
pixmap = QtGui.QPixmap( image )
icon = QtGui.QIcon( pixmap )
self.chaineIconsList.addIcon( nom, icon )
# map( lambda ( x, y ) : self.chaineIconsList.addIcon( x, y ), listeChaines )
def ajouterEmissions( self, listeEmissions ):
"""
Met en place la liste des emissions
"""
listeEmissions.sort()
self.nettoyerWidgets( plugins = False, chaines = False, emissions = True, fichiers = True, description = True )
map( lambda x : self.emissionComboBox.addItem( stringToQstring( x ) ), listeEmissions )
# S'il n'y a qu'une seule emission
if( self.emissionComboBox.count() == 1 ):
# Lance le listage des fichiers
self.listerFichiers( self.emissionComboBox.currentText() )
else:
# Ne selectionne pas le plugin
self.emissionComboBox.setCurrentIndex( -1 )
def ajouterFichiers( self, listeFichiers ):
"""
Met en place la liste des fichiers
"""
self.nettoyerWidgets( plugins = False, chaines = False, emissions = False, fichiers = False, description = True )
self.fichierTableView.model().changeFiles( listeFichiers )
self.fichierTableView.sortByColumn( 1, QtCore.Qt.DescendingOrder ) # Affiche automatiquement les fichiers les plus recents
self.fichierTableView.resizeColumnsToContents()
def ajouterTelechargement( self, index ):
"""
Met en place la liste des telechargements
"""
# Ajoute le fichier au downloadManager
fichier = self.fichierTableView.model().listeFichiers[ index.row() ]
idTelechargement = self.downloadManager.download( fichier )
def afficherDescriptionFichier( self, selected, deselected ):
"""
Affiche les informations du fichier selectionne
"""
def threadRecupererImageDescription( self, urlImage ):
try:
imageData = self.navigateur.getFile( urlImage )
except :
logger.warning( "Impossible de récuperer l'image, utilisation de l'image par défaut" )
imageData = self.logoDefautPixmap
self.emit( self.nouvelleImageDescriptionSignal, imageData )
if( selected.indexes() != deselected.indexes() ):
fichier = self.fichierTableView.model().listeFichiers[ selected.indexes()[ 0 ].row() ]
# Affiche la description
self.descriptionPlainTextEdit.clear()
if( fichier.descriptif != "" ):
self.descriptionPlainTextEdit.appendPlainText( stringToQstring( fichier.descriptif ) )
else:
self.descriptionPlainTextEdit.appendPlainText( u"Aucune information disponible" )
# Recupere l'image
if( fichier.urlImage != "" ):
threading.Thread( target = threadRecupererImageDescription, args = ( self, fichier.urlImage ) ).start()
else:
self.afficherImageDescription( self.logoDefautPixmap )
def afficherImageDescription( self, image ):
"""
Affiche l'image de description du fichier selectionne
"""
if( not isinstance( image, QtGui.QPixmap ) ):
imageOk = QtGui.QPixmap()
imageOk.loadFromData( image )
else:
imageOk = image
self.fichierLabel.setPixmap( imageOk.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) )
def afficherConfiguration( self ):
"""
Affiche la configuration
"""
# Repertoire de telechargement
repertoire = self.config.get( Configuration.TVD_REPERTOIRE_TELECHARGEMENT )
self.choixRepertoire.setDir( repertoire )
# Timeout du navigateur
timeout = self.config.get( Configuration.NAVIGATEUR_TIMEOUT )
self.timeOutSpinBox.setValue( int( timeout ) )
# Nombre de threads max du navigateur
threadMax = self.config.get( Configuration.NAVIGATEUR_THREADS )
self.threadSpinBox.setValue( int( threadMax ) )
def nettoyerWidgets( self, plugins = False, chaines = False, emissions = False, fichiers = False, description = False ):
"""
Nettoie les widgets
"""
if( plugins ):
self.pluginComboBox.clear()
if( chaines ):
self.chaineIconsList.clear()
if( emissions ):
self.emissionComboBox.clear()
if( fichiers ):
self.ajouterFichiers( [] )
if( description ):
self.afficherImageDescription( self.logoDefautPixmap )
self.descriptionPlainTextEdit.clear()
def enregistrerConfiguration( self, elmt, valeur ):
"""
Enregistre la configuration
"""
self.config.set( elmt, valeur )
def getCurrentSelectedDownload( self ):
"""
Renvoie l'indice du telechargement selectionne
"""
rows = self.telechargementsWidget.selectionModel().selectedRows()
if( len( rows ) == 1 ):
return rows[ 0 ].row()
else:
return -1
# def suspendreTelechargement( self ):
# """
# Suspend le telechargement selectionne
# """
# row = self.getCurrentSelectedDownload()
# if( row != -1 ):
def supprimerTelechargement( self ):
"""
Supprime le telechargement selectionne
"""
row = self.getCurrentSelectedDownload()
if( row != -1 ):
self.downloadManager.stopDownload( self.telechargementsWidget.model().listeStatus[ row ].num )
self.telechargementsWidget.model().removeDownload( row )
class TelechargementsCallback( DownloadCallback ):
"""
Callback appelee lors de la mise a jour d'un telechargement
"""
def __init__( self, telechargementsWidget ):
DownloadCallback.__init__( self )
self.telechargementsWidget = telechargementsWidget
def downloadStatus( self, status ):
self.telechargementsWidget.model().changeStatus( status )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import argparse
import lockfile
import logging
logger = None
from multiprocessing.managers import BaseManager
import os
import runpy
import sys
import threading
import tvdcore
import tvdcore.Constantes as Constantes
#
# Gestion des UIs
#
LAUNCHER_ADDRESS = ('', 5096)
LAUNCHER_AUTHKEY = "tvdkey"
UI_RUN__NAME__ = "__tvdui__"
flock = lockfile.FileLock( Constantes.REPERTOIRE_CONFIGURATION )
def isLaunched():
return flock.is_locked()
def lockLaunch():
try:
flock.acquire(20)
except Exception as e:
return False
return True
def unlockLaunch():
try:
flock.release()
except Exception as e:
return
class UICallback():
def __init__(self):
pass
def onEnd(self, uiname):
pass
class UIRunner(threading.Thread):
def __init__(self, callback, name, path):
threading.Thread.__init__(self)
self.callback = callback
self.name = name
self.path = path
def run(self):
if os.path.isfile(self.path):
runpy.run_path(self.path, init_globals=None, run_name=UI_RUN__NAME__)
logger.info("UI "+self.name+" fermée")
else:
logger.error("L'ui "+self.path+" est introuvable")
self.callback.onEnd(self.name)
class UILauncher(threading.Thread, UICallback):
def __init__(self):
threading.Thread.__init__(self)
UICallback.__init__(self)
self.threads = {}
def lauchUI(self, name, path):
if name in self.threads:
logger.warning("L'ui "+name+" est déjà lancée")
else:
self.threads[name] = UIRunner(self, name, path)
self.threads[name].start()
def hasActiveUI(self):
return len(self.threads) > 0
def onEnd(self, uiname):
self.threads.pop(uiname)
#
# Main
#
if( __name__ == "__main__" ):
# Arguments de la ligne de commande
usage = "tvdownloader [options]"
parser = argparse.ArgumentParser( usage = usage )
parser.add_argument( "--ui", dest = "uiname", metavar = "UI_NAME", default = "qt", help = "nom de l'UI a utiliser (qt par defaut)" )
parser.add_argument( "--unlock", action = "store_true", default = False, help = "je ne sais pas quoi mettre" )
parser.add_argument( "-v", "--verbose", action = "store_true", default = False, help = "affiche les informations de debugage" )
parser.add_argument( "--nocolor", action = 'store_true', default = False, help = "désactive la couleur dans le terminal" )
parser.add_argument( "--version", action = 'version', version = "tvdownloader %s" %( Constantes.TVD_VERSION ) )
args = parser.parse_args()
# Mise en place du logger de TVDownloader
logger = logging.getLogger( "TVDownloader" )
console = logging.StreamHandler( sys.stdout )
if( args.verbose ):
logger.setLevel( logging.DEBUG )
console.setLevel( logging.DEBUG )
else:
logger.setLevel( logging.INFO )
console.setLevel( logging.INFO )
console.setFormatter( tvdcore.ColorFormatter( not args.nocolor ) )
logger.addHandler( console )
# Mise en place du logger des fichiers de base
loggerBase = logging.getLogger( "base" )
consoleBase = logging.StreamHandler( sys.stdout )
if( args.verbose ):
loggerBase.setLevel( logging.DEBUG )
consoleBase.setLevel( logging.DEBUG )
else:
loggerBase.setLevel( logging.INFO )
consoleBase.setLevel( logging.INFO )
consoleBase.setFormatter( tvdcore.ColorFormatter( not args.nocolor ) )
loggerBase.addHandler( consoleBase )
#
if( args.unlock ):
flock.break_lock()
sys.exit( 0 )
# Verification de la presence de l'UI
pathUi = "./uis/%s/main.py" %( args.uiname )
if( not os.path.isfile( pathUi ) ):
logger.critical( "L'UI %s est introuvable" %( args.uiname ) )
sys.exit( 1 )
#
if isLaunched():
#TODO Appel au laucher d'ui dans le processus lancé
BaseManager.register('getUILauncher')
manager = BaseManager(LAUNCHER_ADDRESS, LAUNCHER_AUTHKEY)
manager.connect()
launcher = manager.getUILauncher()
launcher.lauchUI(args.uiname, pathUi)
else:
#lockLaunch()
context = tvdcore.TVDContext()
if not(context.isInitialized()) and not(context.initialize()):
logger.error("Impossible d'initialiser le context")
sys.exit(1)
#Mise à disposition du laucher
launcher = UILauncher()
launcher.lauchUI(args.uiname, pathUi)
BaseManager.register('getUILauncher', callable=lambda:launcher)
manager = BaseManager(LAUNCHER_ADDRESS, LAUNCHER_AUTHKEY)
manager.start()
pluginMan = context.pluginManager
import time
while launcher.hasActiveUI():
time.sleep(0.1)
manager.shutdown()
pluginMan.fermeture()
context.historique.sauverHistorique()
context.release()
#unlockLaunch()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import collections
import dateutil.parser
import os
import xml.sax
import tvdcore
#
# Classes
#
Podcast = collections.namedtuple( "Podcast", [ "nom", "urlImage" ] )
class Podcasts( tvdcore.Plugin ):
"""
Classe generique pour charger des podcasts
Pour ajouter le support d'un podcast, il suffit de l'ajouter a la liste ci dessous
"""
listePodcasts = { Podcast( nom = "Allo Cine", urlImage = "http://images.allocine.fr/commons/logos/rss/allocine.png" ) : { "Bandes Annonces" : "http://rss.allocine.fr/bandesannonces/ipod" },
Podcast( nom = "Casse Croute", urlImage = "http://www.casse-croute.fr/rw_common/themes/cassecroute/images/stripe/header_bg850.jpg" ) : { "Recettes" : "http://www.casse-croute.fr/media/cassecroute.xml" },
Podcast( nom = "Gameone", urlImage = "http://gameone-net.mtvnimages.com/Images/logo-g1-programmes-scenic-updated.jpg" ) : { "JT E-NEWS" : "http://podcast13.streamakaci.com/xml/GAMEONE2.xml",
"JT REPORTAGE & DOSSIERS" : "http://podcast13.streamakaci.com/xml/GAMEONE6.xml",
"PLAY HIT" : "http://podcast13.streamakaci.com/xml/GAMEONE9.xml",
"Funky Web" : "http://podcast13.streamakaci.com/xml/GAMEONE26.xml",
"JT LE TEST" : "http://podcast13.streamakaci.com/xml/GAMEONE3.xml"
},
Podcast( nom = "i>TELE", urlImage = "http://podcast123.streamakaci.com/iTELE/images/iTele_Triangle_rouge.gif" ) : { "Le Journal" : "http://podcast12.streamakaci.com/iTELE/iTELElejournal.xml" }
}
def __init__( self ):
tvdcore.Plugin.__init__( self, nom = "Podcasts", url = "", frequence = 0, logo = None )
self.derniereChaine = {}
self.listeFichiers = []
def rafraichir( self ):
pass
def listerChaines( self ):
listeChaines = self.listePodcasts.keys()
listeChaines.sort( key = lambda x : x.nom )
map( self.ajouterChaine, listeChaines )
def listerEmissions( self, chaine ):
chaineTupleList = [ x for x in self.listePodcasts if x.nom == chaine ]
if( len( chaineTupleList ) == 1 ):
self.derniereChaine = self.listePodcasts[ chaineTupleList[ 0 ] ]
listeEmissions = self.derniereChaine.keys()
listeEmissions.sort()
map( lambda x : self.ajouterEmission( chaine, x ), listeEmissions )
def listerFichiers( self, emission ):
if( self.derniereChaine.has_key( emission ) ):
# RAZ de la liste des fichiers
del self.listeFichiers[ : ]
# Recupere la page de l'emission
page = self.getPage( self.derniereChaine[ emission ] )
# Handler
handler = PodcastsHandler( self.listeFichiers )
# Parse le fichier xml
try:
xml.sax.parseString( page, handler )
except:
logger.error( "Impossible de parser le fichier XML" )
return
# Ajoute les fichiers
map( lambda x : self.ajouterFichier( emission, x ), self.listeFichiers )
class PodcastsHandler( xml.sax.handler.ContentHandler ):
"""
Classe pour parser les fichiers XML de description des podcasts
Ces fichiers sont generiques et fonctionnent pour un grand nombre de sites
"""
def __init__( self, listeFichiers ):
# Liste des fichiers
self.listeFichiers = listeFichiers
# Url de l'image globale
self.urlImageGlobale = ""
# Initialisation des variables a Faux
self.isItem = False
self.isTitle = False
self.isDescription = False
self.isPubDate = False
self.isGuid = False
def startElement( self, name, attrs ):
if( name == "item" ):
self.isItem = True
self.titre = ""
self.date = ""
self.urlFichier = ""
self.urlImage = ""
self.description = ""
elif( name == "title" and self.isItem ):
self.isTitle = True
elif( name == "description" and self.isItem ):
self.isDescription = True
elif( name == "pubDate" and self.isItem ):
self.isPubDate = True
elif( name == "media:thumbnail" and self.isItem ):
self.urlImage = attrs.get( "url", "" )
elif( name == "media:content" and self.isItem ):
self.urlFichier = attrs.get( "url", "" )
elif( name == "guid" and self.isItem ):
self.isGuid = True
elif( name == "itunes:image" and not self.isItem ):
self.urlImageGlobale = attrs.get( "href", "" )
def characters( self, data ):
if( self.isTitle ):
self.titre += data
elif( self.isDescription ):
if( data.find( "<" ) == -1 ):
self.description += data
else:
self.isDescription = False
elif( self.isPubDate ):
self.date = data
self.isPubDate = False
elif( self.isGuid ):
self.urlFichier = data
self.isGuid = False
def endElement( self, name ):
if( name == "item" ):
# Extrait l'extension du fichier
basename, extension = os.path.splitext( self.urlFichier )
# Convertit la date
try:
self.dateOk = dateutil.parser.parse( self.date )
except:
self.dateOk = self.date
# Si le fichier n'a pas d'image, utilise l'image globale
if( self.urlImage == "" ):
self.urlImage = self.urlImageGlobale
# Ajoute le fichier
self.listeFichiers.append( tvdcore.Fichier ( self.titre, self.dateOk, self.urlFichier, self.titre + extension, self.urlImage, self.description ) )
self.isTitle = False
elif( name == "description" ):
self.isDescription = False
elif( name == "title" ):
self.isTitle = False
| Python |
#!/usr/bin/env python
# -*- encoding: UTF-8 -*-
from tvdcore import Fichier
from tvdcore import Plugin
class DevPlugin( Plugin ):
DATA = {
"Image Google": {
"Lapins": [
Fichier("Lapin mignon",
lien="http://www.bestioles.ca/mammiferes/images/lapin.jpg",
nomFichierSortie="Lapin mignon.jpg",
urlImage = "http://www.bestioles.ca/mammiferes/images/lapin.jpg",
descriptif = "Le lapin est un petit mammifère qui nous vient d'Europe. Les moines du Moyen Age l'ont domestiqué, pour sa chair et sa fourrure. Cependant, le lapin Angora et la Zibeline sont élevés pour leur poil soyeux."),
Fichier("Bugs bunny",
lien="http://www.cuniculture.info/Docs/Phototheque/Dessins/BugsBunny/Bugs-dessins/bugs-dessin-083.jpg",
nomFichierSortie="Bugs Bunny.jpg",
urlImage="http://www.cuniculture.info/Docs/Phototheque/Dessins/BugsBunny/Bugs-dessins/bugs-dessin-083.jpg",
descriptif="On ne le présente plus.")
],
"Chats": [
Fichier("Bébé chat :)",
lien="http://images.doctissimo.fr/1/animaux/passion-fonds-ecrans/photo/hd/1914725191/1799052ade/passion-fonds-ecrans-chat-big.jpg",
nomFichierSortie="Chaton.jpg",
urlImage="http://upload.wikimedia.org/wikipedia/commons/thumb/6/60/Cat_silhouette.svg/150px-Cat_silhouette.svg.png",
descriptif="Un bébé chat tout mimi."
)
]
},
"Fichier divers": {
"Logiciel": [
Fichier("Avast 7",
lien="http://ftp01net.telechargement.fr/avast_free_antivirus_setup.exe",
nomFichierSortie="Avast_7.exe",
urlImage="http://videonoob.fr/wp-content/uploads/logo-avast-antivirus-5.png",
descriptif="Antivirus gratuit !"
)
]
}
}
def __init__( self ):
Plugin.__init__( self, "DevPlugin", "http://www.google.fr/", 7 )
def listerChaines( self ):
for nom in DevPlugin.DATA.keys():
self.ajouterChaine( ( nom, None ) )
def listerEmissions( self, chaine ):
if DevPlugin.DATA.has_key(chaine):
for emission in DevPlugin.DATA[chaine].keys():
self.ajouterEmission(chaine, emission)
def listerFichiers( self, emission ):
for chaine in DevPlugin.DATA.keys():
if DevPlugin.DATA[chaine].has_key(emission):
for fichier in DevPlugin.DATA[chaine][emission]:
self.ajouterFichier(emission, fichier)
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import BeautifulSoup
import dateutil.parser
import logging
logger = logging.getLogger( "TVDownloader" )
import os
import re
import xml.sax
import tvdcore
from Podcasts import PodcastsHandler
#
# Classe
#
class FranceInter( tvdcore.Plugin ):
listeChaines = { "Emissions" : "http://www.franceinter.fr/emissions/liste-des-emissions",
"Chroniques" : "http://www.franceinter.fr/emissions/liste-des-chroniques"
}
def __init__( self ):
tvdcore.Plugin.__init__( self, "France Inter", "http://www.franceinter.fr", 14 )
self.listeEmissions = {} # { Nom chaine : { Nom emission : URL fichier XML } }
self.derniereChaine = {}
if( os.path.exists( self.fichierCache ) ):
self.listeEmissions = self.chargerCache()
def rafraichir( self ):
# RAZ de la liste des emissions
self.listeEmissions.clear()
# Recupere le XML de description de toutes les emissions
for ( chaine, urlChaine ) in self.listeChaines.items():
self.listeEmissions[ chaine ] = {}
pageHtml = self.getPage( urlChaine )
soupStrainer = BeautifulSoup.SoupStrainer( "a", { "class" : "visuel" } )
pageSoup = BeautifulSoup.BeautifulSoup( pageHtml, parseOnlyThese = soupStrainer )
# Liste des pages des emissions
listePagesUrl = map( lambda x : "%s%s" %( "http://www.franceinter.fr" , x[ "href" ] ), pageSoup.contents )
# Recupere toutes les pages
listePagesData = self.getPages( listePagesUrl )
for emission in pageSoup.contents:
try:
nomEmission = emission[ "title" ]
urlPageEmission = "%s%s" %( "http://www.franceinter.fr" , emission[ "href" ] )
# Extrait le lien XML de la page de l'emission
urlXml = re.findall( "http://radiofrance-podcast.net/podcast09/rss_\d+?.xml", listePagesData[ urlPageEmission ] )[ 0 ]
# Ajoute l'emission a la liste
self.listeEmissions[ chaine][ nomEmission ] = urlXml
except:
continue
# Sauvegarde la liste dans le cache
self.sauvegarderCache( self.listeEmissions )
def listerChaines( self ):
map( lambda x : self.ajouterChaine( ( x, None ) ), self.listeEmissions.keys() )
def listerEmissions( self, chaine ):
if( self.listeEmissions.has_key( chaine ) ):
self.derniereChaine = self.listeEmissions[ chaine ]
map( lambda x : self.ajouterEmission( chaine, x ), self.derniereChaine.keys() )
def listerFichiers( self, emission ):
if( self.derniereChaine.has_key( emission ) ):
urlXmlEmission = self.derniereChaine[ emission ]
xmlEmission = self.getPage( urlXmlEmission )
# Extrait les fichiers
listeFichiers = []
handler = PodcastsHandler( listeFichiers )
try:
xml.sax.parseString( xmlEmission, handler )
except:
logger.error( "Impossible de parser le fichier XML %s" %( urlXmlEmission ) )
return
# Ajoute les fichiers
map( lambda x : self.ajouterFichier( emission, x ), listeFichiers )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import datetime
import logging
logger = logging.getLogger( "TVDownloader" )
import os
import re
import time
import xml.sax
import tvdcore
#
# Classes
#
class CanalPlus( tvdcore.Plugin ):
urlFichierXMLListeProgrammes = "http://www.canalplus.fr/rest/bootstrap.php?/bigplayer/initPlayer"
urlFichierXMLEmissions = "http://www.canalplus.fr/rest/bootstrap.php?/bigplayer/getMEAs/"
urlFichierXMLFichiers = "http://www.canalplus.fr/rest/bootstrap.php?/bigplayer/getVideos/"
def __init__( self ):
tvdcore.Plugin.__init__( self, "Canal+", "http://www.canalplus.fr/", 7 )
self.listeProgrammes = {} # { Nom chaine : { Nom emission : ID emission } }
self.derniereChaine = {}
if( os.path.exists( self.fichierCache ) ):
self.listeProgrammes = self.chargerCache()
def rafraichir( self ):
# RAZ de la liste des programmes
self.listeProgrammes.clear()
# Recupere la page qui contient les infos
pageXML = self.getPage( self.urlFichierXMLListeProgrammes )
# Handler
handler = CanalPlusListeProgrammesHandler( self.listeProgrammes )
# Parse le fichier xml
try:
xml.sax.parseString( pageXML, handler )
except:
logger.error( "Impossible de parser le fichier XML de la liste des programmes" )
return
# Sauvegarde la liste dans le cache
self.sauvegarderCache( self.listeProgrammes )
def listerChaines( self ):
map( lambda x : self.ajouterChaine( ( x, None ) ), self.listeProgrammes )
def listerEmissions( self, chaine ):
if( self.listeProgrammes.has_key( chaine ) ):
self.derniereChaine = self.listeProgrammes[ chaine ]
map( lambda x : self.ajouterEmission( chaine, x ), self.derniereChaine.keys() )
def listerFichiers( self, emission ):
if( self.derniereChaine.has_key( emission ) ):
IDEmission = self.derniereChaine[ emission ]
# Recupere la page qui contient les ids des fichiers
pageXML = self.getPage( self.urlFichierXMLEmissions + IDEmission )
# Extrait les ids
listeIDs = re.findall( "<ID>(.+?)</ID>", pageXML )
# Construit la liste des liens a recuperer
listeURL = []
for IDFichier in listeIDs:
listeURL.append( self.urlFichierXMLFichiers + IDFichier )
# Recupere les pages correspondantes
pagesXML = self.getPages( listeURL )
# Parse chacune de ces pages
for URL in listeURL:
pageXMLFichier = pagesXML[ URL ]
# Handler
infosFichier = []
handler = CanalPlusListeFichierHandler( infosFichier )
# Parse le fichier xml
try:
xml.sax.parseString( pageXMLFichier, handler )
except:
logger.error( "Impossible de parser le fichier XML de la liste des fichiers" )
continue
# Ajoute le fichier
nom, date, lienLD, lienMD, lienHD, urlImage, descriptif = infosFichier
if( lienHD != "" and lienHD[ : 4 ] == "rtmp" ):
# Extrait l'extension du fichier
basename, extension = os.path.splitext( lienHD )
self.ajouterFichier( emission, tvdcore.Fichier( "[HD]" + nom, date, lienHD, nom + extension, urlImage, descriptif ) )
elif( lienMD != "" and lienMD[ : 4 ] == "rtmp" ):
# Extrait l'extension du fichier
basename, extension = os.path.splitext( lienMD )
self.ajouterFichier( emission, tvdcore.Fichier( "[MD]" + nom, date, lienMD, nom + extension, urlImage, descriptif ) )
elif( lienLD != "" and lienLD[ : 4 ] == "rtmp" ):
# Extrait l'extension du fichier
basename, extension = os.path.splitext( lienLD )
self.ajouterFichier( emission, tvdcore.tvdcore.Fichier( "[LD]" + nom, date, lienLD, nom + extension, urlImage, descriptif ) )
class CanalPlusListeProgrammesHandler( xml.sax.handler.ContentHandler ):
"""
Classe pour paser le XML qui liste les emissions
"""
def __init__( self, listeProgrammes ):
# Liste des programmes
self.listeProgrammes = listeProgrammes
# Liste des emissions d'un programme (temporaire)
# Clef : nom emission, Valeur : ID
self.listeEmissions = {}
# Initialisation des variables a Faux
self.nomChaineConnu = False
self.isNomChaine = False
self.isIDEmission = False
self.nomEmissionConnu = False
self.isNomEmission = False
def startElement( self, name, attrs ):
if( name == "THEMATIQUE" ):
pass
elif( name == "NOM" and self.nomChaineConnu == False ):
self.isNomChaine = True
elif( name == "ID" and self.nomChaineConnu == True ):
self.isIDEmission = True
elif( name == "NOM" and self.nomChaineConnu == True ):
self.isNomEmission = True
def characters( self, data ):
if( self.isNomChaine ):
self.nomChaine = data
self.nomChaineConnu = True
self.isNomChaine = False
elif( self.isIDEmission ):
self.IDEmission = data
self.isIDEmission = False
elif( self.isNomEmission ):
self.nomEmission = data
self.nomEmissionConnu = True
self.isNomEmission = False
def endElement( self, name ):
if( name == "THEMATIQUE" ):
self.listeProgrammes[ self.nomChaine.title() ] = self.listeEmissions
self.listeEmissions = {}
self.nomChaineConnu = False
elif( name == "NOM" and self.nomEmissionConnu ):
self.listeEmissions[ self.nomEmission.title() ] = self.IDEmission
self.nomEmissionConnu = False
class CanalPlusListeFichierHandler( xml.sax.handler.ContentHandler ):
"""
Classe qui parse le XML de description d'un fichier
"""
def __init__( self, infosFichier ):
# Liste des programmes
self.infosFichier = infosFichier
# Il n'y a pas forcement les 3 liens
self.lienLD = ""
self.lienMD = ""
self.lienHD = ""
# Initialisation des variables a Faux
self.isTitre = False
self.isDate = False
self.isLienLD = False
self.isLienMD = False
self.isLienHD = False
self.isLienImage = False
self.isDescriptif = False
def startElement( self, name, attrs ):
if( name == "DESCRIPTION" ):
self.descriptif = ""
self.isDescriptif = True
elif( name == "DATE" ):
self.isDate = True
elif( name == "TITRAGE" ):
self.titre = ""
elif( name == "TITRE" or name == "SOUS_TITRE" ):
self.isTitre = True
elif( name == "PETIT" ):
self.isLienImage = True
elif( name == "BAS_DEBIT" ):
self.isLienLD = True
elif( name == "HAUT_DEBIT" ):
self.isLienMD = True
elif( name == "HD" ):
self.isLienHD = True
def characters( self, data ):
if( self.isDescriptif ):
self.descriptif += data
elif( self.isDate ):
self.date = data
self.isDate = False
elif( self.isTitre ):
self.titre += " %s" %( data )
self.isTitre = False
elif( self.isLienImage ):
self.urlImage = data
self.isLienImage = False
elif( self.isLienLD ):
self.lienLD = data
self.isLienLD = False
elif( self.isLienHD ):
self.lienHD = data
self.isLienHD = False
def endElement( self, name ):
if( name == "DESCRIPTION" ):
self.isDescriptif = False
elif( name == "VIDEO" ):
# Convertit la date
try:
self.dateOk = datetime.datetime.fromtimestamp( time.mktime( time.strptime( self.date, "%d/%m/%Y" ) ) )
except:
self.dateOk = self.date
self.infosFichier[ : ] = self.titre, self.dateOk, self.lienLD, self.lienMD, self.lienHD, self.urlImage, self.descriptif
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import base64
from Crypto.Cipher import DES
import datetime
import os
import pickle
import re
import time
import unicodedata
import xml.sax
import tvdcore
import logging
logger = logging.getLogger( "TVDownloader" )
#
# Filtre Wireshark :
# http.host == "www.m6replay.fr"
#
#
# Classe
#
class M6Replay( tvdcore.Plugin ):
urlInfosXML = "http://www.m6replay.fr/files/configurationm6_lv3.xml"
def __init__( self ):
tvdcore.Plugin.__init__( self, "M6Replay", "www.m6replay.fr/", 1, "M6.jpg" )
self.listeFichiers = {} # Clefs = nomChaine, Valeurs = { nomEmission, [ [ Episode 1, Date1, URL1 ], ... ] }
self.listeEmissionsCourantes = {}
if( os.path.exists( self.fichierCache ) ):
self.listeFichiers = self.chargerCache()
def rafraichir( self ):
logger.debug( "récupération de la liste des chaines, des émissions et des fichiers" )
# Remet a 0 la liste des fichiers
self.listeFichiers.clear()
# Recupere la page qui contient les infos sur M6
pageInfos = self.getPage( self.urlInfosXML )
# Extrait l'URL du catalogue
try :
urlCatalogue = re.findall( "http://www.m6replay.fr/catalogue/\w+.xml", pageInfos )[ 0 ]
print urlCatalogue
except:
logger.error( "impossible de recuperer l'URL du catalogue" )
return
# Recupere le catalogue chiffre
catalogue = self.getPage( urlCatalogue )
# Classe pour dechiffrer le catalogue
decryptor = DES.new( "ElFsg.Ot", DES.MODE_ECB )
# Page des emissions (catalogue dechiffre)
pageEmissions = decryptor.decrypt( base64.decodestring( catalogue ) )
# Cherche la fin du fichier XML
finXML = pageEmissions.find( "</template_exchange_WEB>" ) + len( "</template_exchange_WEB>" )
# Enleve ce qui est apres la fin du fichier XML
pageEmissions = pageEmissions[ : finXML ]
# Handler
handler = M6ReplayHandler( self.listeFichiers )
# Parse le fichier xml
try :
xml.sax.parseString( pageEmissions, handler )
except:
logger.error( "impossible de parser le fichier XML" )
return
# Sauvegarde la liste dans le cache
self.sauvegarderCache( self.listeFichiers )
logger.debug( "liste des programmes sauvegardée" )
def listerChaines( self ):
for chaine in self.listeFichiers.keys():
self.ajouterChaine( chaine )
def listerEmissions( self, chaine ):
if( self.listeFichiers.has_key( chaine ) ):
self.listeEmissionsCourantes = self.listeFichiers[ chaine ]
for emission in self.listeEmissionsCourantes.keys():
self.ajouterEmission( chaine, emission )
else:
logger.warning( 'chaine "%s" introuvable' %( chaine ) )
def listerFichiers( self, emission ):
if( self.listeEmissionsCourantes.has_key( emission ) ):
listeFichiers = self.listeEmissionsCourantes[ emission ]
for ( nom, date, lien, urlImage, descriptif ) in listeFichiers:
lienValide = "rtmpe://m6dev.fcod.llnwd.net:443/a3100/d1/mp4:production/regienum/" + lien
urlImage = "http://images.m6replay.fr" + urlImage
# Transforme la date en type datetime.date
dateBonFormat = datetime.datetime( *( time.strptime( date, "%Y-%m-%d %H:%M:%S" ) )[ 0 : 3 ] )
# Extrait l'extension du fichier
basename, extension = os.path.splitext( lien )
self.ajouterFichier( emission, tvdcore.Fichier( nom, dateBonFormat, lienValide, nom + extension, urlImage, descriptif ) )
else:
logger.warning( 'emission "%s" introuvable pour la chaine courante' %( emission ) )
#
# Parser XML pour M6Replay
#
## Classe qui permet de lire les fichiers XML de M6Replay
class M6ReplayHandler( xml.sax.handler.ContentHandler ):
# Constructeur
# @param listeFichiers Liste des fichiers que le parser va remplir
def __init__( self, listeFichiers ):
# Liste des fichiers
self.listeFichiers = listeFichiers
# Liste des emissions (temporaire, ajoute au fur et a mesure dans listeFichiers)
self.listeEmissions = {}
# Liste des videos (temporaire, ajoute au fur et a mesure dans listeEmissions)
self.listeVideos = []
# Initialisation des variables a Faux
self.nomChaineConnu = False
self.nomEmissionConnu = False
self.nomEpisodeConnu = False
self.nomVideoConnu = False
self.isNomChaine = False
self.isNomEmission = False
self.isNomEpisode = False
self.isNomVideo = False
self.isResume = False
## Methode appelee lors de l'ouverture d'une balise
# @param name Nom de la balise
# @param attrs Attributs de cette balise
def startElement( self, name, attrs ):
if( name == "categorie" ):
if( self.nomChaineConnu ):
# Commence une nouvelle emission
pass
else:
# Commence une nouvelle chaine
pass
elif( name == "nom" ):
# Si on a nom, cela peut etre (toujours dans cet ordre) :
# - Le nom de la chaine
# - Le nom de l'emission
# - Le nom d'un episode de cette emission
# - Le nom de la vidéo de cet episode
# De plus, si on ne connait pas la nom de la chaine, alors le 1er nom rencontre est le nom de la chaine
if( self.nomChaineConnu ):
if( self.nomEmissionConnu ):
if( self.nomEpisodeConnu ): # Nom de la video
self.isNomVideo = True
else: # Nom de l'episode
self.isNomEpisode = True
else: # Nom de l'emission
self.isNomEmission = True
else: # Nom de la chaine
self.isNomChaine = True
elif( name == "diffusion" ):
self.dateEpisode = attrs.get( "date", "" )
elif( name == "resume" ):
self.isResume = True
elif( name == "produit" ):
self.image = attrs.get( "sml_img_url", "" )
## Methode qui renvoie les donnees d'une balise
# @param data Donnees d'une balise
def characters( self, data ):
data = unicodedata.normalize( 'NFKD', data ).encode( 'ascii','ignore' )
if( self.isNomChaine ):
self.nomChaine = data
self.nomChaineConnu = True
self.isNomChaine = False
elif( self.isNomEmission ):
self.nomEmission = data
self.nomEmissionConnu = True
self.isNomEmission = False
elif( self.isNomEpisode ):
self.nomEpisode = data
self.nomEpisodeConnu = True
self.isNomEpisode = False
elif( self.isNomVideo ):
self.nomVideo = data
self.nomVideoConnu = True
self.isNomVideo = False
elif( self.isResume ):
self.resume = data
self.isResume = False
## Methode appelee lors de la fermeture d'une balise
# @param name Nom de la balise
def endElement( self, name ):
if( name == "categorie" ):
if( self.nomEmissionConnu ): # Fini de traiter une emission
self.listeEmissions[ self.nomEmission.title() ] = self.listeVideos
self.listeVideos = []
self.nomEmissionConnu = False
else: # Fini de traiter une chaine
self.listeFichiers[ self.nomChaine.title() ] = self.listeEmissions
self.listeEmissions = {}
self.nomChaineConnu = False
elif( name == "nom" ):
pass
elif( name == "diffusion" ):
self.listeVideos.append( [ self.nomEpisode.title(), self.dateEpisode, self.nomVideo, self.image, self.resume ] )
self.nomEpisodeConnu = False
self.nomVideoConnu = False
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import datetime
import os
import pickle
import re
import time
import unicodedata
import urllib
import xml.sax
import tvdcore
import logging
logger = logging.getLogger( "TVDownloader" )
#
# Filtre Wireshark :
# http.host == "www.w9replay.fr"
#
#
# Classe
#
class W9Replay( tvdcore.Plugin ):
urlInfosXML = "http://www.w9replay.fr/files/w9configuration_lv3.xml"
def __init__( self ):
tvdcore.Plugin.__init__( self, "W9Replay", "http://www.w9replay.fr/", 1, "W9.jpg" )
self.listeFichiers = {} # Clefs = nomChaine, Valeurs = { nomEmission, [ [ Episode 1, Date1, URL1 ], ... ] }
self.listeEmissionsCourantes = {}
# Charge le cache
if( os.path.exists( self.fichierCache ) ):
self.listeFichiers = self.chargerCache()
def rafraichir( self ):
logger.debug( "récupération de la liste des chaines, des émissions et des fichiers" )
# Remet a zero la liste des fichiers
self.listeFichiers.clear()
# Recupere la page qui contient les infos sur W9
pageInfos = self.getPage( self.urlInfosXML )
# Extrait l'URL du catalogue
try :
urlCatalogue = re.findall( "http://www.w9replay.fr/catalogue/\d+.xml", pageInfos )[ 0 ]
except:
logger.error( "impossible de recuperer l'URL du catalogue" )
return
# Recupere la page qui contient les infos
pageXML = self.getPage( urlCatalogue )
# Handler
handler = W9ReplayHandler( self.listeFichiers )
# Parse le fichier xml
try :
xml.sax.parseString( pageXML, handler )
except:
logger.error( "impossible de parser le fichier XML" )
return
# Sauvegarde la liste dans le cache
self.sauvegarderCache( self.listeFichiers )
logger.debug( "liste des programmes sauvegardée" )
def listerChaines( self ):
for chaine in self.listeFichiers.keys():
self.ajouterChaine( chaine )
def listerEmissions( self, chaine ):
if( self.listeFichiers.has_key( chaine ) ):
self.listeEmissionsCourantes = self.listeFichiers[ chaine ]
for emission in self.listeEmissionsCourantes.keys():
self.ajouterEmission( chaine, emission )
else:
logger.warning( 'chaine "%s" introuvable' %( chaine ) )
def listerFichiers( self, emission ):
if( self.listeEmissionsCourantes.has_key( emission ) ):
listeFichiers = self.listeEmissionsCourantes[ emission ]
for ( nom, date, lien, urlImage, descriptif ) in listeFichiers:
lienValide = "rtmpe://m6dev.fcod.llnwd.net:443/a3100/d1/mp4:production/w9replay/" + lien
urlImage = "http://images.w9replay.fr" + urlImage
# Transforme la date en type datetime.date
dateBonFormat = datetime.datetime( *( time.strptime( date, "%Y-%m-%d %H:%M:%S" ) )[ 0 : 3 ] )
# Extrait l'extension du fichier
basename, extension = os.path.splitext( lien )
self.ajouterFichier( emission, tvdcore.Fichier( nom, dateBonFormat, lienValide, nom + extension, urlImage, descriptif ) )
else:
logger.warning( 'emission "%s" introuvable pour la chaine courante' %( emission ) )
#
# Parser XML pour W9Replay
#
## Classe qui permet de lire les fichiers XML de W9Replay
class W9ReplayHandler( xml.sax.handler.ContentHandler ):
# Constructeur
# @param listeFichiers Liste des fichiers que le parser va remplir
def __init__( self, listeFichiers ):
# Liste des fichiers
self.listeFichiers = listeFichiers
# Liste des emissions (temporaire, ajoute au fur et a mesure dans listeFichiers)
self.listeEmissions = {}
# Liste des videos (temporaire, ajoute au fur et a mesure dans listeEmissions)
self.listeVideos = []
# Initialisation des variables a Faux
self.nomChaineConnu = False
self.nomEmissionConnu = False
self.nomEpisodeConnu = False
self.nomVideoConnu = False
self.isNomChaine = False
self.isNomEmission = False
self.isNomEpisode = False
self.isNomVideo = False
self.isResume = False
## Methode appelee lors de l'ouverture d'une balise
# @param name Nom de la balise
# @param attrs Attributs de cette balise
def startElement( self, name, attrs ):
if( name == "categorie" ):
if( self.nomChaineConnu ):
# Commence une nouvelle emission
pass
else:
# Commence une nouvelle chaine
pass
elif( name == "nom" ):
# Si on a nom, cela peut etre (toujours dans cet ordre) :
# - Le nom de l'emission
# - Le nom d'un episode de cette emission
# - Le nom de la vidéo de cet episode
# De plus, si on ne connait pas la nom de la chaine, alors le 1er nom rencontre est le nom de la chaine
if( self.nomChaineConnu ):
if( self.nomEmissionConnu ):
if( self.nomEpisodeConnu ): # Nom de la video
self.isNomVideo = True
else: # Nom de l'episode
self.isNomEpisode = True
else: # Nom de l'emission
self.isNomEmission = True
else: # Nom de la chaine
self.isNomChaine = True
elif( name == "diffusion" ):
self.dateEpisode = attrs.get( "date", "" )
elif( name == "resume" ):
self.isResume = True
elif( name == "produit" ):
self.image = attrs.get( "sml_img_url", "" )
## Methode qui renvoie les donnees d'une balise
# @param data Donnees d'une balise
def characters( self, data ):
data = unicodedata.normalize( 'NFKD', data ).encode( 'ascii','ignore' )
if( self.isNomChaine ):
self.nomChaine = data
self.nomChaineConnu = True
self.isNomChaine = False
elif( self.isNomEmission ):
self.nomEmission = data
self.nomEmissionConnu = True
self.isNomEmission = False
elif( self.isNomEpisode ):
self.nomEpisode = data
self.nomEpisodeConnu = True
self.isNomEpisode = False
elif( self.isNomVideo ):
self.nomVideo = data
self.nomVideoConnu = True
self.isNomVideo = False
elif( self.isResume ):
self.resume = data
self.isResume = False
## Methode appelee lors de la fermeture d'une balise
# @param name Nom de la balise
def endElement( self, name ):
if( name == "categorie" ):
if( self.nomEmissionConnu ): # Fini de traiter une emission
self.listeEmissions[ self.nomEmission.title() ] = self.listeVideos
self.listeVideos = []
self.nomEmissionConnu = False
else: # Fini de traiter une chaine
self.listeFichiers[ self.nomChaine.title() ] = self.listeEmissions
self.listeEmissions = {}
self.nomChaineConnu = False
elif( name == "nom" ):
pass
elif( name == "diffusion" ):
self.listeVideos.append( [ self.nomEpisode.title(), self.dateEpisode, self.nomVideo, self.image, self.resume ] )
self.nomEpisodeConnu = False
self.nomVideoConnu = False
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import HTMLParser
# import datetime
# import os.path
import re
# import xml.sax
import tvdcore
import logging
logger = logging.getLogger( "TVDownloader" )
#
# Filtre Wireshark :
# http.host contains "tf1" or http.host contains "wat"
#
#
# Classe
#
class TF1( tvdcore.Plugin ):
listeChaines = { u"Séries étrangères" : "/series-etrangeres/",
u"Fictions françaises" : "/fictions-francaises/",
u"Téléréalités" : "/telerealites/",
u"Magazine" : "/magazine/",
u"Divertissement" : "/divertissement/",
u"Info" : "/programmes-tv-info/",
u"Sport" : "/sport/",
u"Jeux tv" : "/jeux-tv/" }
def __init__( self ):
tvdcore.Plugin.__init__( self, "TF1", "http://videos.tf1.fr", 1, "TF1.jpg" )
def rafraichir( self ):
pass
def listerChaines( self ):
for chaine in self.listeChaines.keys():
self.ajouterChaine( chaine )
def listerEmissions( self, chaine ):
if( self.listeChaines.has_key( chaine ) ):
urlChaine = "http://videos.tf1.fr%s" %( self.listeChaines[ chaine ] )
self.listeEmissions = {} # Clefs = nom de l'emission, Valeurs = [] avec nom, date, lien
# Recupere la premiere page
page = self.getPage( urlChaine )
# Extrait le nombre max de pages
try :
pageMax = re.findall( "<li>(\d+?) pages :", page )[ 0 ]
# Le programme ne charge pour l'instant que les 10 premieres pages
# TODO : Ajouter une option
if( pageMax > 10 ):
pageMax = 10
except :
pageMax = 10
logger.debug( "impossible de trouver le nombre max de pages de %s, il est fixé à 10" %( urlChaine ) )
# Recupere une par une les pages et en extrait les infos
for i in range( 2, pageMax + 1 ):
# Charge la page
url = "%s%d/" %( urlChaine, i )
page = self.getPage( url )
# Extrait les infos des vidéos
try :
parser = TF1ProgrammesParser( self )
parser.feed( page )
except :
logger.error( "impossible de parser la page %s" %( url ) )
continue
# Affiche la liste des emissions
for emission in self.listeEmissions.keys():
self.ajouterEmission( chaine, emission )
else:
logger.warning( 'chaine "%s" introuvable' %( chaine ) )
def mettreEnPlaceEmission( self, nomEmission, nomFichier, date, lien ):
if( self.listeEmissions.has_key( nomEmission ) ):
self.listeEmissions[ nomEmission ].append( ( nomFichier, date, lien ) )
else:
self.listeEmissions[ nomEmission ] = [ ( nomFichier, date, lien ) ]
def listerFichiers( self, emission ):
pass
class TF1ProgrammesParser( HTMLParser.HTMLParser ):
## Constructeur
def __init__( self, tf1 ):
HTMLParser.HTMLParser.__init__( self )
self.tf1 = tf1
self.isDate = False
self.isNomEmission = False
self.isTitre = False
## Methode appelee lors de l'ouverture d'une balise
# @param tag Tag de la balise
# @param attrs Attributs de la balise
def handle_starttag( self, tag, attrs ):
if( tag == "div" and attrs == [ ( 'class', 'date t3 c5' ) ] ):
self.isDate = True
self.nomEmission = ""
elif( tag == "div" and attrs == [ ( 'class', 'prog t4 c5' ) ] ):
self.isNomEmission = True
elif( tag == "h3" and attrs == [ ( 'class', 'titre t4' ) ] ):
self.isTitre = True
self.titre = ""
elif( self.isTitre and tag == "a" and attrs[ 0 ][ 0 ] == "href" ):
self.lien = attrs[ 0 ][ 1 ]
## Methode qui renvoit les donnees d'une balise
# @param data Donnees de la balise
def handle_data( self, data ):
if( self.isDate ):
self.date = data
self.isDate = False
elif( self.isNomEmission ):
self.nomEmission = data
self.isNomEmission = False
elif( self.isTitre ):
self.titre += data
## Methode appelee lors de la fermeture d'une balise
# @param tag Tag de la balise
def handle_endtag( self, tag ):
if( self.isTitre and tag == "a" ):
self.isTitre = False
if( self.nomEmission == "" ):
self.nomEmission = "Divers"
self.tf1.mettreEnPlaceEmission( self.nomEmission, self.titre, self.date, self.lien )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import unicodedata
import re
import string
import logging
logger = logging.getLogger( "base.string" )
#
# Functions
#
def removeAccents( myStr ):
"""
Removes all accents
"""
if( isinstance( myStr, str ) ):
myStr = unicode( myStr, "utf8", "replace" )
myStr = unicodedata.normalize( 'NFD', myStr )
myStr = myStr.encode( 'ascii', 'ignore' )
return myStr
def toFileName( myStr ):
"""
Transform string to usable filename
"""
myStr = removeAccents( myStr )
myStr = "".join( [ char for char in myStr if char in string.ascii_letters or char in string.digits or char == " " or char == "." ] )
myStr = re.sub( r"\s+", "_", myStr )
return myStr
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtLogWidget( QtGui.QTableWidget ):
"""
Widget to display Python log messages
"""
def __init__( self, parent = None ):
# 0 rown 3 columns
QtGui.QTableWidget.__init__( self, parent )
self.setColumnCount( 3 )
# Change columns names
self.setHorizontalHeaderItem( 0, QtGui.QTableWidgetItem( "Type" ) )
self.setHorizontalHeaderItem( 1, QtGui.QTableWidgetItem( "Fichier" ) )
self.setHorizontalHeaderItem( 2, QtGui.QTableWidgetItem( "Message" ) )
# Hide rows names
self.verticalHeader().setVisible( False )
# Always select one line
self.setSelectionBehavior( QtGui.QAbstractItemView.SelectRows )
self.setSelectionMode( QtGui.QAbstractItemView.SingleSelection )
# Hide grid
self.setShowGrid( False )
# Last column takes all free space
self.horizontalHeader().setStretchLastSection( True )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import logging
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtLogHandler( logging.Handler ):
"""
Display Python logging messages with Qt ; use it with a QTableWidget widget
"""
# Colors
red = QtGui.QColor( 255, 0, 0, 127 )
yellow = QtGui.QColor( 255, 255, 0, 127 )
green = QtGui.QColor( 0, 255, 0, 127 )
white = QtGui.QColor( 255, 255, 255, 127 )
# Color levels
colorLevel = { "ERROR" : red, "WARNING" : yellow, "CRITICAL" : red, "INFO" : green, "DEBUG" : white }
def __init__( self, widget ):
logging.Handler.__init__( self )
self.widget = widget
self.formater = logging.Formatter( "%(levelname)s;%(filename)s;%(message)s" )
def createItem( self, text, color ):
"""
Create new item to display
"""
item = QtGui.QTableWidgetItem( stringToQstring( text ) )
item.setBackground( color )
item.setFlags( QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled )
return item
def emit( self, record ):
"""
Parse log message and display it
"""
typeMsg, fileMsg, msg = self.formater.format( record ).split( ";" )
color = self.colorLevel[ typeMsg ]
self.widget.insertRow( 0 )
self.widget.setItem( 0, 0, self.createItem( typeMsg, color ) )
self.widget.setItem( 0, 1, self.createItem( fileMsg, color ) )
self.widget.setItem( 0, 2, self.createItem( msg, color ) )
def createLock( self ):
self.mutex = QtCore.QMutex()
def acquire( self ):
self.mutex.lock()
def release( self ):
self.mutex.unlock()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from PyQt4 import QtCore
import unicodedata
#
# Functions
#
def stringToQstring( text ):
"""
Convert a Python string to a Qt string
"""
if( isinstance( text, str ) ):
return QtCore.QString( unicode( text, "utf-8", "replace" ) )
else:
return QtCore.QString( text )
def qstringToString( text ):
"""
Convert a Qt string to a Python string
"""
return unicode( text.toUtf8(), "utf-8" )
# try:
# return str( text.toUtf8() )
# except UnicodeDecodeError:
# return unicode( text.toUtf8(), "utf-8" )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import os
from base.qt.qtString import qstringToString
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtFolderChooser( QtGui.QWidget ):
"""
Widget to choose a folder
"""
def __init__( self, parent = None, icon = None ):
QtGui.QWidget.__init__( self, parent )
# Layout
self.folderChooserLayout = QtGui.QHBoxLayout()
self.setLayout( self.folderChooserLayout )
# Line edit
self.folderChooserLineEdit = QtGui.QLineEdit( parent )
self.folderChooserLayout.addWidget( self.folderChooserLineEdit )
# Push button
self.folderChooserPushButton = QtGui.QPushButton( parent )
if( icon ):
self.folderChooserPushButton.setIcon( icon )
QtCore.QObject.connect( self.folderChooserPushButton,
QtCore.SIGNAL( "clicked()" ),
self.folderChooser )
self.folderChooserLayout.addWidget( self.folderChooserPushButton )
def folderChooser( self ):
"""
Open window
"""
currenDir = QtGui.QFileDialog.getExistingDirectory( None,
u"",
self.folderChooserLineEdit.text(),
QtGui.QFileDialog.ShowDirsOnly
)
if( os.path.isdir( currenDir ) ):
self.folderChooserLineEdit.setText( currenDir )
self.emit( QtCore.SIGNAL( "valueChanged(PyQt_PyObject)" ), currenDir )
def getDir( self ):
"""
Get dir
"""
return qstringToString( self.folderChooserLineEdit.text() )
def setDir( self, dirPath ):
"""
Set dir
"""
self.folderChooserLineEdit.setText( stringToQstring( dirPath ) )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import logging
logger = logging.getLogger( "base.Patterns" )
#
# Classes
#
class Singleton( type ):
"""
Singleton pattern
Use "__metaclass__ = Patterns.Singleton" to use it in our classes
"""
def __init__( cls, name, bases, dict ):
super( Singleton, cls ).__init__( name, bases, dict )
cls.instance = None
def __call__( cls, *args, **kwargs ):
if( cls.instance is None ):
cls.instance = super( Singleton, cls ).__call__( *args, **kwargs )
return cls.instance
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
# Adapted from :
# Brandon Thomson
# http://stackoverflow.com/questions/384076/how-can-i-make-the-python-logging-output-to-be-colored
#
# Modules
#
import logging
#
# Class
#
class ColorFormatter( logging.Formatter ):
FORMAT = ( "[%(levelname)-19s] " "$BOLD%(filename)-20s$RESET" "%(message)s" )
# FORMAT = ( "[%(levelname)-18s] " "($BOLD%(filename)s$RESET:%(lineno)d) " "%(message)s" )
BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range( 8 )
RESET_SEQ = "\033[0m"
COLOR_SEQ = "\033[1;%dm"
BOLD_SEQ = "\033[1m"
COLORS = {
'WARNING' : YELLOW,
'INFO' : GREEN,
'DEBUG' : WHITE,
'CRITICAL' : RED,
'ERROR' : RED
}
def __init__( self, use_color ):
self.use_color = use_color
msg = self.formatter_msg( self.FORMAT )
logging.Formatter.__init__( self, msg )
def formatter_msg( self, msg ):
if( self.use_color ):
msg = msg.replace( "$RESET", self.RESET_SEQ ).replace( "$BOLD", self.BOLD_SEQ )
else:
msg = msg.replace( "$RESET", "" ).replace( "$BOLD", "" )
return msg
def format( self, record ):
levelname = record.levelname
if( self.use_color and levelname in self.COLORS ):
fore_color = 30 + self.COLORS[ levelname ]
levelname_color = self.COLOR_SEQ % fore_color + levelname + self.RESET_SEQ
record.levelname = levelname_color
return logging.Formatter.format( self, record )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import cookielib
import random
import threading
import urllib
import urllib2
from base.cache.BrowserCache import BrowserCache
from base.Patterns import Singleton
import logging
logger = logging.getLogger( "base.Browser" )
#
# Classe
#
class Browser( object ):
__metaclass__ = Singleton
timeOut = 10
maxThread = 10
userAgentsList = [ 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_5; fr-fr) AppleWebKit/525.18 (KHTML, like Gecko) Version/3.1.2 Safari/525.20.1',
'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.186 Safari/535.1',
'Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13',
'Mozilla/5.0 (X11; U; Linux x86_64; en-us) AppleWebKit/528.5+ (KHTML, like Gecko, Safari/528.5+) midori',
'Mozilla/5.0 (Windows NT 6.0) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.107 Safari/535.1',
'Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en-us) AppleWebKit/312.1 (KHTML, like Gecko) Safari/312',
'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.12 Safari/535.11',
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.8 (KHTML, like Gecko) Chrome/17.0.940.0 Safari/535.8' ]
def __init__( self, proxy = None ):
# HTTP proxy
self.proxy = proxy
# Cookiejar + urlopener
self.cookiejar = cookielib.CookieJar()
if( proxy is None ):
self.urlOpener = urllib2.build_opener( urllib2.HTTPCookieProcessor( self.cookiejar ) )
else:
self.urlOpener = urllib2.build_opener( urllib2.HTTPCookieProcessor( self.cookiejar ), urllib2.ProxyHandler( { 'http' : self.proxy } ) )
# User-agent
self.urlOpener.addheaders = [ ( 'User-agent', random.choice( self.userAgentsList ) ) ]
# Lock for threads
self.lock = threading.Lock()
# Semaphore
self.semaphore = threading.Semaphore( self.maxThread )
# Condition "no thread running"
self.noThreadRunning = threading.Condition()
# Number of running threads
self.runningThreads = 0
@BrowserCache( maxSize = 10 * 1024 * 1024, acceptedTypes = [ "text", "image" ] )
def getFile( self, url, data = None ):
if( url is None or len( url ) == 0 ):
return None
try:
logger.debug( "GET %s" %( url ) )
if( data is not None ):
request = urllib2.Request( url, urllib.urlencode( data ) )
else:
request = urllib2.Request( url )
page = self.urlOpener.open( request, timeout = self.timeOut )
pageData = page.read()
return pageData
except urllib2.URLError, e :
if( hasattr( e, 'reason' ) ):
logger.debug( e.reason )
elif( hasattr( e, 'code' ) ):
logger.debug( "Erreur %d" %( e.code ) )
raise
except:
raise
## Use threads to download several files with data
# @param urlList URL list [ ( url, data ) ]
# @return dictionnary { ( url, data ) : page }
def getFilesWithData( self, urlList ):
def threadGetFile( self, pageArgs, pagesDict ):
# Thread += 1
with self.lock:
self.runningThreads += 1
# Get data
( url, data ) = pageArgs
try:
page = self.getFile( url, data )
except:
page = ""
# Save data and thread -= 1
with self.lock:
if( data is None ):
fdata = None
else:
fdata = frozenset( data.items() )
pagesDict[ ( url, fdata ) ] = page
self.runningThreads -= 1
with self.noThreadRunning:
if( self.runningThreads == 0 ):
self.noThreadRunning.notify()
self.semaphore.release()
pagesDict = {}
currentFile = 0
if( len( urlList ) == 0 ):
return pagesDict
# Launch threads
while( currentFile < len( urlList ) ):
self.semaphore.acquire()
threading.Thread( target = threadGetFile,
args = ( self, urlList[ currentFile ], pagesDict )
).start()
currentFile += 1
# Wait the end of all threads
with self.noThreadRunning:
if( self.runningThreads != 0 ):
self.noThreadRunning.wait()
return pagesDict
## Use threads to download several files
# @param urlList URL list [ url ]
# @return dictionnary { url : page }
def getFiles( self, urlList ):
urlListWithData = map( lambda x : ( x, None ), urlList )
pagesDictWithData = self.getFilesWithData( urlListWithData )
pagesDict = {}
for ( url, data ) in pagesDictWithData.keys():
pagesDict[ url ] = pagesDictWithData[ ( url, data ) ]
return pagesDict
def appendCookie( self, cookieName, cookieValue ):
for cookie in self.cookiejar:
if( cookie.name == cookieName ):
cookie.value += "; %s" %( cookieValue )
break
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import functools
import logging
logger = logging.getLogger( "base.decorators" )
#
# Decorators
#
def deprecated( fnct ):
"""
Decorator to mark deprecated function
"""
@functools.wraps( fnct )
def logDeprecated( *args, **kwargs ):
logger.warning( "Deprecated function %s ; don't use it !" %( fnct.__name__ ) )
return fnct( *args, **kwargs )
return logDeprecated
def synchronized( lock ):
"""
Decorator to synchronize several methods with a given lock
"""
def wrapper( fnct ):
@functools.wraps( fnct )
def sync( *args, **kwargs ):
with lock:
return fnct( *args, **kwargs )
return sync
return wrapper
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import ConfigParser
import os
import threading
from base.decorators import synchronized
from base.Patterns import Singleton
import logging
logger = logging.getLogger( "base.Config" )
#
# Classe
#
# Create mutex
mutex = threading.Lock()
class Config( object ):
__metaclass__ = Singleton
def __init__( self, configFileName ):
self.configFileName = configFileName
# Create ConfigParser instance
self.configParser = ConfigParser.ConfigParser()
# Open config file
self.open()
@synchronized( mutex )
def open( self ):
if( os.path.exists( self.configFileName ) ):
self.configParser.read( self.configFileName )
@synchronized( mutex )
def save( self ):
# N.B. : only one thread has to call this function
with open( self.configFileName, "w" ) as configFile:
self.configParser.write( configFile )
@synchronized( mutex )
def get( self, section, option ):
if( self.configParser.has_option( section, option ) ):
return self.configParser.get( section, option )
else:
return None
@synchronized( mutex )
def set( self, section, option, value ):
if( not self.configParser.has_section( section ) ):
self.configParser.add_section( section )
self.configParser.set( section, option, value )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from APIPrive import APIPrive
from base.Browser import Browser
from base.Patterns import Singleton
import logging
logger = logging.getLogger( "tvdownloader" )
#
# Class
#
class API( APIPrive ):
__metaclass__ = Singleton
def __init__( self ):
APIPrive.__init__( self )
self.browser = Browser()
## Récupère une page web
# @param url URL de la page
# @param data POST data { name : value }
# @return page web
def getPage( self, url, data = None ):
return self.browser.getFile( url, data )
## Récupère plusieurs pages sur le web
# @param urlListe Liste des URLs [ ( url, data ) ]
# @return pages web { ( url, data ) : page }
def getPages( self, urlListe ):
return self.browser.getFiles( urlList )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtTable( QtGui.QTableWidget ):
"""
Custom version of QTableWidget
"""
def __init__( self, parent = None ):
QtGui.QTableWidget.__init__( self, parent )
# No line number
self.verticalHeader().setVisible( False )
# No grid
self.setShowGrid( False )
# Always select only one line
self.setSelectionBehavior( QtGui.QAbstractItemView.SelectRows )
self.setSelectionMode( QtGui.QAbstractItemView.SingleSelection )
# Alternate colors
self.setAlternatingRowColors( True )
def resizeColumnsToContents( self ):
"""
Resize all columns
"""
QtGui.QTableWidget.resizeColumnsToContents( self )
if( not self.isHorizontalScrollBarVisible() ):
self.horizontalHeader().setStretchLastSection( True )
def clear( self ):
"""
Clear contents
"""
QtGui.QTableWidget.clear()
self.resizeColumnsToContents()
def isHorizontalScrollBarVisible( self ):
"""
Is horizontal scroll bar visible ?
"""
isVisible = False
columnSize = 0
for i in range( self.columnCount() ):
columnSize += self.columnWidth( i )
widgetSize = self.width()
if( columnSize > widgetSize ):
isVisible = True
return isVisible
def createItem( self, text, editable = False, checkBox = False, checked = False ):
"""
Return a new item for QtTable
"""
item = QtGui.QTableWidgetItem( stringToQstring( text ) )
item.setTextAlignment( QtCore.Qt.AlignCenter )
if( not editable ):
item.setFlags( item.flags() & ~QtCore.Qt.ItemIsEditable )
if( checkBox ):
if( checked ):
item.setCheckState( QtCore.Qt.Checked )
else:
item.setCheckState( QtCore.Qt.Unchecked )
return item
def getLine( self, row ):
"""
Get a line (use it with setLine)
"""
line = []
for i in range( self.columnCount() ):
line.append( self.takeItem( row, i ) )
return line
def copyLine( self, row ):
"""
Get a line (use it with setLine)
"""
line = []
for i in range( self.columnCount() ):
line.append( self.item( row, i ).clone() )
return line
def setLine( self, row, line ):
"""
Set a line (use it with getLine and copyLine)
"""
columnNum = self.columnCount()
if( len( line ) == columnNum ):
for i in range( columnNum ):
self.setItem( row, i, line[ i ] )
def swapLines( self, row1, row2 ):
"""
Swap two lines
"""
if( row1 != row2 ):
line1 = self.getLine( row1 )
self.setLine( row1, self.getLine( row2 ) )
self.setLine( row2, line1 )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtIconsList( QtGui.QScrollArea ):
"""
Widget to display a list of icons (QIcon)
"""
iconsSize = QtCore.QSize( 100, 100 )
def __init__( self, parent = None ):
QtGui.QScrollArea.__init__( self )
self.setWidgetResizable( True )
self.setHorizontalScrollBarPolicy( QtCore.Qt.ScrollBarAlwaysOff )
self.setMinimumHeight( 125 )
self.setMinimumWidth( 150 )
# Widget
self.widget = QtGui.QWidget( parent )
self.setWidget( self.widget )
# Vertical layout
self.layout = QtGui.QVBoxLayout( self.widget )
# Array to store icons names
self.buttonsNames = []
# Button group
self.buttonGroup = QtGui.QButtonGroup( self.widget )
self.buttonGroup.setExclusive( True )
QtCore.QObject.connect( self.buttonGroup,
QtCore.SIGNAL( "buttonClicked(int)" ),
self.buttonClicked )
def clear( self ):
"""
Clear icons list
"""
self.buttonsNames = []
for button in self.buttonGroup.buttons():
self.layout.removeWidget( button )
self.buttonGroup.removeButton( button )
def addIcon( self, name, icon = None ):
"""
Add an icon to the list
icon must be a QIcon
"""
if( icon ):
button = QtGui.QPushButton( icon, "", self.widget )
button.setIconSize( self.iconsSize )
else:
button = QtGui.QPushButton( stringToQstring( name ), self.widget )
button.setFlat( True )
button.setCheckable( True )
button.setToolTip( stringToQstring( name ) )
self.layout.addWidget( button )
self.buttonGroup.addButton( button, len( self.buttonsNames ) - 1 )
self.buttonsNames.append( name )
def buttonClicked( self, buttonId ):
"""
When a button is clicked, a signal is emitted with button name
"""
self.emit( QtCore.SIGNAL( "buttonClicked(PyQt_PyObject)" ), self.buttonsNames[ buttonId ] )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import operator
import threading
import sys
sys.path.append( ".." )
from base.qt.QtFolderChooser import QtFolderChooser
from base.qt.qtString import qstringToString
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
from qt.QtIconsList import QtIconsList
from qt.QtTable import QtTable
#
# Classe
#
class MainWindow( QtGui.QMainWindow ):
"""
TVDownloader MainWindows
"""
def __init__( self, tvdVersion ):
"""
Constructeur
"""
# Appel au constructeur de la classe mere
QtGui.QMainWindow.__init__( self )
#
# Fonts
#
# Font pour les titres
self.titreFont = QtGui.QFont()
self.titreFont.setPointSize( 11 )
self.titreFont.setWeight( 75 )
self.titreFont.setBold( True )
#
# Icones
#
self.tvdIco = QtGui.QIcon( "ico/TVDownloader.png" )
self.folderIco = QtGui.QIcon( "ico/gtk-folder.svg" )
# self.addIco = QtGui.QIcon( "ico/gtk-add.svg" )
# self.applyIco = QtGui.QIcon( "ico/gtk-apply.svg" )
# self.fileIco = QtGui.QIcon( "ico/gtk-file.svg" )
#
# Signaux
#
# Liste des plugins a mettre en place
self.listePluginsSignal = QtCore.SIGNAL( "listePlugins(PyQt_PyObject)" )
QtCore.QObject.connect( self, self.listePluginsSignal , self.ajouterPlugins )
# Liste des chaines a mettre en place
self.listeChainesSignal = QtCore.SIGNAL( "listeChaines(PyQt_PyObject)" )
QtCore.QObject.connect( self, self.listeChainesSignal , self.ajouterChaines )
# Liste des emissions a mettre en place
self.listeEmissionsSignal = QtCore.SIGNAL( "listeEmission(PyQt_PyObject)" )
QtCore.QObject.connect( self, self.listeEmissionsSignal , self.ajouterEmissions )
#
# Reglages de la fenetre
#
# Nom de la fenetre
self.setWindowTitle( "TVDownloader %s" %( tvdVersion ) )
# Mise en place de son icone
self.setWindowIcon( self.tvdIco )
#
# Widget central de la fenetre
#
# Widget central qui contiendra tout
self.centralWidget = QtGui.QWidget( self )
self.setCentralWidget( self.centralWidget )
# Layout de grille pour le widget central
self.centralGridLayout = QtGui.QGridLayout( self.centralWidget )
#
# Onglets
#
# Gestionnaire onglets
self.tabWidget = QtGui.QTabWidget( self.centralWidget )
self.centralGridLayout.addWidget( self.tabWidget, 0, 0, 1, 1 )
# Onglet Fichiers
self.fichiersSplitter = QtGui.QSplitter( self.centralWidget )
self.tabWidget.addTab( self.fichiersSplitter, u"Choix des fichiers" )
# Onglet Telechargements
self.telechargementsWidget = QtGui.QScrollArea( self.centralWidget )
self.tabWidget.addTab( self.telechargementsWidget, u"Téléchargements" )
# Onglet Parametres
self.parametresWidget = QtGui.QWidget( self.centralWidget )
self.tabWidget.addTab( self.parametresWidget, u"Paramètres" )
#
# Onglet Fichiers
#
# Widget choix de la chaine
self.chaineWidget = QtGui.QWidget( self.fichiersSplitter )
self.fichiersSplitter.addWidget( self.chaineWidget )
# Layout vertical
self.chaineLayout = QtGui.QVBoxLayout( self.chaineWidget )
# Choix du plugin
self.pluginComboBox = QtGui.QComboBox( self.chaineWidget )
QtCore.QObject.connect( self.pluginComboBox,
QtCore.SIGNAL( "activated(QString)" ),
self.listerChaines )
self.chaineLayout.addWidget( self.pluginComboBox )
# Liste des chaines
self.chaineIconsList = QtIconsList( self.chaineWidget )
QtCore.QObject.connect( self.chaineIconsList,
QtCore.SIGNAL( "buttonClicked(PyQt_PyObject)" ),
self.listerEmissions )
self.chaineLayout.addWidget( self.chaineIconsList )
# Widget choix des fichiers
self.fichierWidget = QtGui.QWidget( self.fichiersSplitter )
self.fichiersSplitter.addWidget( self.fichierWidget )
# Layout vertical
self.fichierLayout = QtGui.QVBoxLayout( self.fichierWidget )
# Choix de l'emission
self.emissionComboBox = QtGui.QComboBox( self.fichierWidget )
self.fichierLayout.addWidget( self.emissionComboBox )
# Liste des fichiers
self.fichierTableWidget = QtTable( self.fichierWidget )
self.fichierTableWidget.setColumnCount( 3 ) # 3 colonnes
self.fichierTableWidget.setRowCount( 0 ) # 0 ligne
self.fichierTableWidget.setHorizontalHeaderItem( 0, self.fichierTableWidget.createItem( "" ) )
self.fichierTableWidget.setHorizontalHeaderItem( 1, self.fichierTableWidget.createItem( "Date" ) )
self.fichierTableWidget.setHorizontalHeaderItem( 2, self.fichierTableWidget.createItem( "Emission" ) )
self.fichierLayout.addWidget( self.fichierTableWidget )
#
# Onglet Parametres
#
# Layout de forumlaire
self.parametresLayout = QtGui.QFormLayout( self.parametresWidget )
# Titre Repertoire
self.titreRepertoireLabel = QtGui.QLabel( self.parametresWidget )
self.titreRepertoireLabel.setFont( self.titreFont )
self.titreRepertoireLabel.setText( u"Répertoires :" )
self.parametresLayout.addRow( self.titreRepertoireLabel, None )
# Repertoire par defaut pour les videos
self.choixRepertoire = QtFolderChooser( self.parametresWidget, self.folderIco )
self.parametresLayout.addRow( u"Répertoire de téléchargement :", self.choixRepertoire )
# Titre Internet
self.titreInternetLabel = QtGui.QLabel( self.parametresWidget )
self.titreInternetLabel.setFont( self.titreFont )
self.titreInternetLabel.setText( u"Paramètres Internet :" )
self.parametresLayout.addRow( self.titreInternetLabel, None )
# Time out du navigateur
self.timeOutSpinBox = QtGui.QSpinBox( self.parametresWidget )
self.timeOutSpinBox.setMinimum( 1 )
self.timeOutSpinBox.setMaximum( 60 )
self.parametresLayout.addRow( u"Time out (en s) :", self.timeOutSpinBox )
# Nombre de threads du navigateur
self.threadSpinBox = QtGui.QSpinBox( self.parametresWidget )
self.threadSpinBox.setMinimum( 1 )
self.threadSpinBox.setMaximum( 100 )
self.parametresLayout.addRow( u"Nombre de threads max :", self.threadSpinBox )
#
# Debut
#
self.actionsAuDebut()
def closeEvent( self, evt ):
"""
Surcharge de la methode appele lors de la fermeture de la fenetre
"""
self.actionsAvantQuitter()
evt.accept()
def actionsAuDebut( self ):
"""
Actions a realiser au demarage du programe
"""
self.listerPlugins()
def actionsAvantQuitter( self ):
"""
Actions a realiser avant de quitter le programme
"""
print "Bye bye"
def listerPlugins( self ):
"""
Fonction qui demande la liste des plugins
"""
def threadListerPlugins( self ):
listePlugins = [ "B", "A", "C", "D" ]
self.emit( self.listePluginsSignal, listePlugins )
threading.Thread( target = threadListerPlugins, args = ( self, ) ).start()
def listerChaines( self, plugin = None ):
"""
Fonction qui demande la liste des chaines d'un plugin donne
Si plugin = None, alors elle demande la liste des chaines de tous les plugins
"""
def threadListerChaines( self, plugin ):
listeChaines = [ ( "4", None ), ( "2", None ), ( "3", None ), ( "1", None ), ( "0", None ), ( "42", None ) ]
self.emit( self.listeChainesSignal, listeChaines )
if( plugin ):
plugin = qstringToString( plugin )
threading.Thread( target = threadListerChaines, args = ( self, plugin ) ).start()
def listerEmissions( self, chaine ):
"""
Fonction qui demande la liste des emissions d'une chaine donnee
"""
def threadListerEmissions( self, chaine ):
listeEmissions = [ "Alpha", "Beta", "Gamma" ]
self.emit( self.listeEmissionsSignal, listeEmissions )
threading.Thread( target = threadListerEmissions, args = ( self, chaine ) ).start()
def ajouterPlugins( self, listePlugins ):
"""
Met en place la liste des plugins donnee
"""
listePlugins.sort()
self.pluginComboBox.clear()
map( lambda x : self.pluginComboBox.addItem( stringToQstring( x ) ), listePlugins )
def ajouterChaines( self, listeChaines ):
"""
Met en place la liste des chaines donnee sous la forme ( nomChaine, logoChaine )
"""
listeChaines = sorted( listeChaines, key = operator.itemgetter( 0 ) )
self.chaineIconsList.clear()
map( lambda ( x, y ) : self.chaineIconsList.addIcon( x, y ), listeChaines )
def ajouterEmissions( self, listeEmissions ):
"""
Met en place la liste des emissions
"""
listeEmissions.sort()
self.emissionComboBox.clear()
map( lambda x : self.emissionComboBox.addItem( stringToQstring( x ) ), listeEmissions )
if __name__ == "__main__" :
app = QtGui.QApplication( sys.argv )
window = MainWindow( "1.0" )
window.show()
sys.exit( app.exec_() )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import unicodedata
import re
import string
import logging
logger = logging.getLogger( "base.string" )
#
# Functions
#
def removeAccents( myStr ):
"""
Removes all accents
"""
if( isinstance( myStr, str ) ):
myStr = unicode( myStr, "utf8", "replace" )
myStr = unicodedata.normalize( 'NFD', myStr )
myStr = myStr.encode( 'ascii', 'ignore' )
return myStr
def toFileName( myStr ):
"""
Transform string to usable filename
"""
myStr = removeAccents( myStr )
myStr = "".join( [ char for char in myStr if char in string.ascii_letters or char in string.digits or char == " " or char == "." ] )
myStr = re.sub( r"\s+", "_", myStr )
return myStr
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtLogWidget( QtGui.QTableWidget ):
"""
Widget to display Python log messages
"""
def __init__( self, parent = None ):
# 0 rown 3 columns
QtGui.QTableWidget.__init__( self, parent )
self.setColumnCount( 3 )
# Change columns names
self.setHorizontalHeaderItem( 0, QtGui.QTableWidgetItem( "Type" ) )
self.setHorizontalHeaderItem( 1, QtGui.QTableWidgetItem( "Fichier" ) )
self.setHorizontalHeaderItem( 2, QtGui.QTableWidgetItem( "Message" ) )
# Hide rows names
self.verticalHeader().setVisible( False )
# Always select one line
self.setSelectionBehavior( QtGui.QAbstractItemView.SelectRows )
self.setSelectionMode( QtGui.QAbstractItemView.SingleSelection )
# Hide grid
self.setShowGrid( False )
# Last column takes all free space
self.horizontalHeader().setStretchLastSection( True )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import logging
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtLogHandler( logging.Handler ):
"""
Display Python logging messages with Qt ; use it with a QTableWidget widget
"""
# Colors
red = QtGui.QColor( 255, 0, 0, 127 )
yellow = QtGui.QColor( 255, 255, 0, 127 )
green = QtGui.QColor( 0, 255, 0, 127 )
white = QtGui.QColor( 255, 255, 255, 127 )
# Color levels
colorLevel = { "ERROR" : red, "WARNING" : yellow, "CRITICAL" : red, "INFO" : green, "DEBUG" : white }
def __init__( self, widget ):
logging.Handler.__init__( self )
self.widget = widget
self.formater = logging.Formatter( "%(levelname)s;%(filename)s;%(message)s" )
def createItem( self, text, color ):
"""
Create new item to display
"""
item = QtGui.QTableWidgetItem( stringToQstring( text ) )
item.setBackground( color )
item.setFlags( QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled )
return item
def emit( self, record ):
"""
Parse log message and display it
"""
typeMsg, fileMsg, msg = self.formater.format( record ).split( ";" )
color = self.colorLevel[ typeMsg ]
self.widget.insertRow( 0 )
self.widget.setItem( 0, 0, self.createItem( typeMsg, color ) )
self.widget.setItem( 0, 1, self.createItem( fileMsg, color ) )
self.widget.setItem( 0, 2, self.createItem( msg, color ) )
def createLock( self ):
self.mutex = QtCore.QMutex()
def acquire( self ):
self.mutex.lock()
def release( self ):
self.mutex.unlock()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
from PyQt4 import QtCore
import unicodedata
#
# Functions
#
def stringToQstring( text ):
"""
Convert a Python string to a Qt string
"""
if( isinstance( text, str ) ):
return QtCore.QString( unicode( text, "utf-8", "replace" ) )
else:
return QtCore.QString( text )
def qstringToString( text ):
"""
Convert a Qt string to a Python string
"""
try:
return str( text.toUtf8() )
except UnicodeDecodeError:
return unicode( text.toUtf8(), "utf-8" )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import os
from base.qt.qtString import qstringToString
from base.qt.qtString import stringToQstring
from PyQt4 import QtCore
from PyQt4 import QtGui
#
# Class
#
class QtFolderChooser( QtGui.QWidget ):
"""
Widget to choose a folder
"""
def __init__( self, parent = None, icon = None ):
QtGui.QWidget.__init__( self, parent )
# Layout
self.folderChooserLayout = QtGui.QHBoxLayout()
self.setLayout( self.folderChooserLayout )
# Line edit
self.folderChooserLineEdit = QtGui.QLineEdit( parent )
self.folderChooserLayout.addWidget( self.folderChooserLineEdit )
# Push button
self.folderChooserPushButton = QtGui.QPushButton( parent )
if( icon ):
self.folderChooserPushButton.setIcon( icon )
QtCore.QObject.connect( self.folderChooserPushButton,
QtCore.SIGNAL( "clicked()" ),
self.folderChooser )
self.folderChooserLayout.addWidget( self.folderChooserPushButton )
def folderChooser( self ):
"""
Open window
"""
currenDir = QtGui.QFileDialog.getExistingDirectory( None,
u"",
self.folderChooserLineEdit.text(),
QtGui.QFileDialog.ShowDirsOnly
)
if( os.path.isdir( currenDir ) ):
self.folderChooserLineEdit.setText( currenDir )
def getDir( self ):
"""
Get dir
"""
return qstringToString( self.folderChooserLineEdit.text() )
def setDir( self, dirPath ):
"""
Set dir
"""
self.folderChooserLineEdit.setText( stringToQstring( dirPath ) )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import logging
logger = logging.getLogger( "base.Patterns" )
#
# Classes
#
class Singleton( type ):
"""
Singleton pattern
Use "__metaclass__ = Patterns.Singleton" to use it in our classes
"""
def __init__( cls, name, bases, dict ):
super( Singleton, cls ).__init__( name, bases, dict )
cls.instance = None
def __call__( cls, *args, **kwargs ):
if( cls.instance is None ):
cls.instance = super( Singleton, cls ).__call__( *args, **kwargs )
return cls.instance
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
# Adapted from :
# Brandon Thomson
# http://stackoverflow.com/questions/384076/how-can-i-make-the-python-logging-output-to-be-colored
#
# Modules
#
import logging
#
# Class
#
class ColorFormatter( logging.Formatter ):
FORMAT = ( "[%(levelname)-19s] " "$BOLD%(filename)-20s$RESET" "%(message)s" )
# FORMAT = ( "[%(levelname)-18s] " "($BOLD%(filename)s$RESET:%(lineno)d) " "%(message)s" )
BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range( 8 )
RESET_SEQ = "\033[0m"
COLOR_SEQ = "\033[1;%dm"
BOLD_SEQ = "\033[1m"
COLORS = {
'WARNING' : YELLOW,
'INFO' : GREEN,
'DEBUG' : WHITE,
'CRITICAL' : RED,
'ERROR' : RED
}
def __init__( self, use_color ):
self.use_color = use_color
msg = self.formatter_msg( self.FORMAT )
logging.Formatter.__init__( self, msg )
def formatter_msg( self, msg ):
if( self.use_color ):
msg = msg.replace( "$RESET", self.RESET_SEQ ).replace( "$BOLD", self.BOLD_SEQ )
else:
msg = msg.replace( "$RESET", "" ).replace( "$BOLD", "" )
return msg
def format( self, record ):
levelname = record.levelname
if( self.use_color and levelname in self.COLORS ):
fore_color = 30 + self.COLORS[ levelname ]
levelname_color = self.COLOR_SEQ % fore_color + levelname + self.RESET_SEQ
record.levelname = levelname_color
return logging.Formatter.format( self, record )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import cookielib
import random
import threading
import urllib
import urllib2
from base.Cache.BrowserCache import BrowserCache
from base.Patterns import Singleton
import logging
logger = logging.getLogger( "base.Browser" )
#
# Classe
#
class Browser( object ):
__metaclass__ = Singleton
timeOut = 10
maxThread = 10
userAgentsList = [ 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_5; fr-fr) AppleWebKit/525.18 (KHTML, like Gecko) Version/3.1.2 Safari/525.20.1',
'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.186 Safari/535.1',
'Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13',
'Mozilla/5.0 (X11; U; Linux x86_64; en-us) AppleWebKit/528.5+ (KHTML, like Gecko, Safari/528.5+) midori',
'Mozilla/5.0 (Windows NT 6.0) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.107 Safari/535.1',
'Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en-us) AppleWebKit/312.1 (KHTML, like Gecko) Safari/312',
'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.12 Safari/535.11',
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.8 (KHTML, like Gecko) Chrome/17.0.940.0 Safari/535.8' ]
def __init__( self, proxy = None ):
# HTTP proxy
self.proxy = proxy
# Cookiejar + urlopener
self.cookiejar = cookielib.CookieJar()
if( proxy is None ):
self.urlOpener = urllib2.build_opener( urllib2.HTTPCookieProcessor( self.cookiejar ) )
else:
self.urlOpener = urllib2.build_opener( urllib2.HTTPCookieProcessor( self.cookiejar ), urllib2.ProxyHandler( { 'http' : self.proxy } ) )
# User-agent
self.urlOpener.addheaders = [ ( 'User-agent', random.choice( self.userAgentsList ) ) ]
# Lock for threads
self.lock = threading.Lock()
# Semaphore
self.semaphore = threading.Semaphore( self.maxThread )
# Condition "no thread running"
self.noThreadRunning = threading.Condition()
# Number of running threads
self.runningThreads = 0
@BrowserCache( maxSize = 10 * 1024 * 1024, acceptedTypes = [ "text", "image" ] )
def getFile( self, url, data = None ):
try:
logger.debug( "GET %s" %( url ) )
if( data is not None ):
request = urllib2.Request( url, urllib.urlencode( data ) )
else:
request = urllib2.Request( url )
page = self.urlOpener.open( request, timeout = self.timeOut )
pageData = page.read()
return pageData
except urllib2.URLError, e :
if( hasattr( e, 'reason' ) ):
logger.debug( e.reason )
elif( hasattr( e, 'code' ) ):
logger.debug( "Erreur %d" %( e.code ) )
raise
except:
raise
## Use threads to download several files
# @param urlList URL list [ ( url, data ) ]
# @return dictionnary { ( url, data ) : page }
def getFiles( self, urlList ):
def threadGetFile( self, pageArgs, pagesDict ):
# Thread += 1
with self.lock:
self.runningThreads += 1
# Get data
( url, data ) = pageArgs
page = self.getFile( url, data )
# Save data and thread -= 1
with self.lock:
if( data is None ):
fdata = None
else:
fdata = frozenset( data.items() )
pagesDict[ ( url, fdata ) ] = page
self.runningThreads -= 1
with self.noThreadRunning:
if( self.runningThreads == 0 ):
self.noThreadRunning.notify()
self.semaphore.release()
pagesDict = {}
currentFile = 0
if( len( urlList ) == 0 ):
return pagesDict
# Launch threads
while( currentFile < len( urlList ) ):
self.semaphore.acquire()
threading.Thread( target = threadGetFile,
args = ( self, urlList[ currentFile ], pagesDict )
).start()
currentFile += 1
# Wait the end of all threads
with self.noThreadRunning:
self.noThreadRunning.wait()
return pagesDict
def appendCookie( self, cookieName, cookieValue ):
for cookie in self.cookiejar:
if( cookie.name == cookieName ):
cookie.value += "; %s" %( cookieValue )
break
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import functools
import logging
logger = logging.getLogger( "base.decorators" )
#
# Decorators
#
def deprecated( fnct ):
"""
Decorator to mark deprecated function
"""
@functools.wraps( fnct )
def logDeprecated( *args, **kwargs ):
logger.warning( "Deprecated function %s ; don't use it !" %( fnct.__name__ ) )
return fnct( *args, **kwargs )
return logDeprecated
def synchronized( lock ):
"""
Decorator to synchronize several methods with a given lock
"""
def wrapper( fnct ):
@functools.wraps( fnct )
def sync( *args, **kwargs ):
with lock:
return fnct( *args, **kwargs )
return sync
return wrapper
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import ConfigParser
import os
import threading
from base.decorators import synchronized
from base.Patterns import Singleton
import logging
logger = logging.getLogger( "base.Config" )
#
# Classe
#
CONFIG_FILE = "toto.cfg"
class Config( object ):
__metaclass__ = Singleton
def __init__( self ):
# Create ConfigParser instance
self.configParser = ConfigParser.ConfigParser()
# Create mutex
self.mutex = threading.Lock()
# Open config file
self.open()
@synchronized( self.mutex )
def open( self ):
if( os.path.exists( CONFIG_FILE ) ):
self.configParser.read( CONFIG_FILE )
@synchronized( self.mutex )
def save( self ):
# N.B. : only one thread has to call this function
with open( CONFIG_FILE, "w" ) as configFile:
self.configParser.write( configFile )
@synchronized( self.mutex )
def get( self, section, option ):
if( self.configParser.has_option( section, option ) ):
return self.configParser.get( section, option )
else:
return None
@synchronized( self.mutex )
def set( self, section, option, value ):
if( not self.configParser.has_section( section ) ):
self.configParser.add_section( section )
self.configParser.set( section, option, value )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os
import pickle
from Fichier import Fichier
##########
# Classe #
##########
## Classe qui gere l'historique des telechargements
class Historique( object ):
# Instance de la classe (singleton)
instance = None
## Surcharge de la methode de construction standard (pour mettre en place le singleton)
def __new__( self, *args, **kwargs ):
if( self.instance is None ):
self.instance = super( Historique, self ).__new__( self )
return self.instance
# Historique : les fichiers sont d'abord hashes selon leur date pour diminuer le temps de recherche
# Ainsi, l'historique est de la forme { date1, [ Fichiers a date1 ], date2, [ Fichiers a date2 ], ... }
## Constructeur
def __init__( self ):
self.home = os.path.expanduser( "~" )
self.fichierHistorique = self.home + "/.tvdownloader/logs/historique"
self.chargerHistorique()
## Methode qui charge l'historique existant
def chargerHistorique( self ):
if os.path.exists( self.fichierHistorique ): # Si le fichier existe, on le charge
fichier = open( self.fichierHistorique, "r" )
self.historique = pickle.load( fichier )
fichier.close()
else: # Sinon, on creee un historique vide
self.historique = {}
## Methode qui ajoute un fichier a l'historique
# @param nouveauFichier Fichier a ajouter a l'historique
def ajouterHistorique( self, nouveauFichier ):
if( isinstance( nouveauFichier, Fichier ) ):
date = getattr( nouveauFichier, "date" )
if( self.historique.has_key( date ) ):
self.historique[ date ].append( nouveauFichier )
else:
self.historique[ date ] = [ nouveauFichier ]
## Methode qui sauvegarde l'historique
def sauverHistorique( self ):
# On enregistre l'historique
fichier = open( self.fichierHistorique, "w" )
pickle.dump( self.historique, fichier )
fichier.close()
## Methode qui verifie si un fichier se trouve dans l'historique
# @param fichier Fichier a chercher dans l'historique
# @return Si le fichier est present ou non dans l'historique
def comparerHistorique( self, fichier ):
if( isinstance( fichier, Fichier ) ):
date = getattr( fichier, "date" )
if( self.historique.has_key( date ) ):
return fichier in self.historique[ date ]
else:
return False
else:
return False
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os
import sys
#############
# Variables #
#############
# du programme
TVD_NOM = "TVDownloader"
TVD_VERSION = "0.8"
# du systeme
OS_UNIX = False
OS_WINDOWS = False
if( sys.platform.lower()[ : 3 ] == "win" ):
OS_WINDOWS = True
else:
OS_UNIX = True
# des chemins
if( "TVDOWNLOADER_HOME" in os.environ ):
REPERTOIRE_HOME = os.path.join( os.environ[ "TVDOWNLOADER_HOME" ] )
REPERTOIRE_CACHE = os.path.join( REPERTOIRE_HOME, "cache" )
REPERTOIRE_CONFIGURATION = os.path.join( REPERTOIRE_HOME, "config" )
elif( "APPDATA" in os.environ ):
REPERTOIRE_HOME = os.path.join( os.environ[ "APPDATA" ], "tvdownloader" )
REPERTOIRE_CACHE = os.path.join( REPERTOIRE_HOME, "cache" )
REPERTOIRE_CONFIGURATION = os.path.join( REPERTOIRE_HOME, "config" )
else:
REPERTOIRE_HOME = os.path.expanduser( "~" )
REPERTOIRE_CACHE = os.path.join( REPERTOIRE_HOME, ".cache", "tvdownloader" )
REPERTOIRE_CONFIGURATION = os.path.join( REPERTOIRE_HOME, ".config", "tvdownloader" )
REPERTOIRE_LOGS = os.path.join( REPERTOIRE_CONFIGURATION, "logs" )
REPERTOIRE_PLUGIN_PERSO = os.path.join( REPERTOIRE_CONFIGURATION, "plugins" )
REPERTOIRE_TELECHARGEMENT_DEFAUT = os.path.join( os.path.expanduser( "~" ), "Videos_TVDownloader" )
# des plugins
REPERTOIRES_PLUGINS = [ REPERTOIRE_PLUGIN_PERSO,
"plugins" ]
# des fichiers
FICHIER_CONFIGURATION_TVD = os.path.join( REPERTOIRE_CONFIGURATION, "tvdownloader" )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import datetime
import os.path
import re
import unicodedata
import logging
logger = logging.getLogger( __name__ )
##########
# Classe #
##########
## Classe qui contient les informations d'un fichier
class Fichier:
## @var nom
# Nom du fichier (tel qu'affiché à l'utilisateur)
## @var date
# Date du fichier sous forme d'une chaîne
## @var lien
# Url où se trouve le fichier
## @var nomFichierSortie
# Nom du fichier en sortie
## @var urlImage
# URL de l'image a afficher avec le Fichier
## @var descriptif
# Texte descriptif du fichier
## Contructeur.
# @param self L'objet courant
# @param nom Le nom du fichier (tel qu'affiché à l'utilisateur)
# @param date La date du fichier sous forme d'une chaîne
# @param lien L'url où se trouve le fichier
# @param nomFichierSortie Nom du fichier de sortie
# @param urlImage URL de l'image a afficher
# @param descriptif Texte descriptif a afficher
def __init__( self, nom = "", date = "", lien = "", nomFichierSortie = "", urlImage = "", descriptif = "" ):
self.nom = nom
self.lien = lien
self.urlImage = urlImage
self.descriptif = self.supprimeBaliseHTML( descriptif )
if( nomFichierSortie == "" ):
self.nomFichierSortie = self.stringToFileName( os.path.basename( self.lien ) )
else:
self.nomFichierSortie = self.stringToFileName( nomFichierSortie )
if( isinstance( date, datetime.date ) ):
self.date = date.isoformat()
else:
self.date = date
## Surcharge de la methode ==
# @param other L'autre Fichier a comparer
# @return Si les 2 Fichiers sont egaux
def __eq__( self, other ):
if not isinstance( other, Fichier ):
return False
else:
return ( self.nom == getattr( other, "nom" ) and \
self.date == getattr( other, "date" ) and \
self.lien == getattr( other, "lien" ) )
## Surcharge de la methode !=
# @param other L'autre Fichier a comparer
# @return Si les 2 Fichiers sont differents
def __ne__( self, other ):
return not self.__eq__( other )
## Methode qui transforme une chaine de caracteres en chaine de caracteres utilisable comme nom de fichiers
# @param chaine Chaine de caracteres a transformer
# @return Chaine de caracteres utilisable en nom de fichiers
def stringToFileName( self, chaine ):
if( isinstance( chaine, str ) ):
chaine = unicode( chaine, "utf8" )
# On supprime les accents
chaineNettoyee = unicodedata.normalize( 'NFKD', chaine ).encode( 'ASCII', 'ignore' )
# On supprimes les espaces
chaineSansEspaces = chaineNettoyee.replace( " ", "_" )
# On supprime les caracteres speciaux
return "".join( [ x for x in chaineSansEspaces if x.isalpha() or x.isdigit() or x == "." ] )
## Methode qui supprime les balises HTML courantes d'une chaine de caractere
# @param chaine Chaine de caracteres a transformer
# @return Chaine de caracteres utilisable en nom de fichiers
def supprimeBaliseHTML( self, chaine ):
p = re.compile( r'<.*?>' )
return p.sub( '', chaine ) | Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import urllib
import urllib2
import mechanize
import random
import re
import threading
import time
import xml.sax.saxutils
import logging
logger = logging.getLogger( __name__ )
#
# Liste d'user agent
#
listeUserAgents = [ 'Mozilla/5.0 (Windows; U; Windows NT 5.1; fr; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1',
'Mozilla/5.0 (Windows; U; Windows NT 6.0; fr; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1',
'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; fr; rv:1.9.0.3) Gecko/2008092414 Firefox/3.0.3',
'Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.0.6) Gecko/2009011913 Firefox/3.0.6',
'Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.1b2) Gecko/20081201 Firefox/3.1b2',
'Mozilla/5.0 (X11; U; Linux i686; fr; rv:1.9.1.1) Gecko/20090715 Firefox/3.5.1',
'Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.2) Gecko/20100115 Firefox/3.6',
'Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13',
'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)',
'Mozilla/5.0 (X11; U; Linux x86_64; en-us) AppleWebKit/528.5+ (KHTML, like Gecko, Safari/528.5+) midori',
'Opera/8.50 (Windows NT 5.1; U; en)',
'Opera/9.80 (X11; Linux x86_64; U; fr) Presto/2.2.15 Version/10.00',
'Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en-us) AppleWebKit/312.1 (KHTML, like Gecko) Safari/312' ]
##########
# Classe #
##########
## Classe Navigateur pour charger les pages web
class Navigateur( object ):
timeOut = 5
maxThread = 10
## Constructeur
def __init__( self ):
# Navigateur
self.navigateur = mechanize.Browser()
#
# Options du Navigateur
#
# User Agent
self.navigateur.addheaders = [ ('User-agent', random.choice( listeUserAgents ) ) ]
#
self.navigateur.set_handle_equiv( True )
# Active compression gzip
#~ self.navigateur.set_handle_gzip( True )
#
self.navigateur.set_handle_redirect( True )
# N'ajoute pas le referer a l'en-tete
self.navigateur.set_handle_referer( False )
# Ne prend pas en compte les robots.txt
self.navigateur.set_handle_robots( False )
# Ne doit pas gerer les cookies
self.navigateur.set_cookiejar( None )
## Methode pour recuperer une page web
# @param URLPage URL de la page web a charger
# @return Code de la page
def getPage( self, URLPage ):
logger.info( "acces a la page %s" %( URLPage ) )
try:
# Page a charger
page = self.navigateur.open( URLPage, timeout = self.timeOut )
# Si le fichier est un XML
if( URLPage[ -4 : ] == ".xml" ):
# On la page telle quelle, sans aucun traitement
return page.read()
else: # Sinon, on va cherche a determiner son encodage
# Donnees de la page
donnees = self.unescape( page.read() )
# On recupere si possible l'encodage de la page
contentType = page.info()[ "Content-type" ]
# Type d'encodage de la page
encodagePage = ""
# On extrait l'encodage
res = re.findall( "charset=(.+)", contentType )
if( len( res ) != 0 ):
encodagePage = res[ 0 ].lower()
# Si on a trouve un encodage et qui n'est pas de l'utf-8
if( encodagePage != "" and encodagePage != "utf-8" ):
# On retourne la page dans le bon encodage
return unicode( donnees, encodagePage ).encode( 'utf-8', 'replace' )
else:
return donnees
except urllib2.URLError, erreur:
try:
logger.error( erreur.reason )
except :
pass
return ""
except:
return ""
## Methode pour recuperer plusieurs pages web
# @param listeURL Liste des URLs des pages web a charger
# @return La liste (dictionnaire) des pages web recuperees { URLPage : Page }
def getPages( self, listeURL ):
## Sous methode qui gere le telechargement d'une page (thread)
# @param URLPage URL de la page a charger
def ajoutPage( self, URLPage ):
# On a un thread lance de plus
self.lock.acquire()
self.nbThreadLances += 1
self.lock.release()
# On recupere la page web
try:
page = self.getPage( URLPage )
except:
page = ""
#~ print "DL de %s fini" %( URLPage )
# On ajoute la page a la liste et on a un thread lance de moins
self.lock.acquire()
self.listePage[ URLPage ] = page
self.nbThreadLances -= 1
self.lock.release()
self.listePage = {}
self.nbThreadLances = 0
indiceActuelListe = 0
tailleListe = len( listeURL )
self.lock = threading.Lock()
# Boucle pour lancer les threads
self.lock.acquire()
while( indiceActuelListe < tailleListe ): # Tant qu'on a pas fini de parcourir la liste
if( self.nbThreadLances < self.maxThread ): # Si on peut encore lance des threads
#~ print "Indice = %d" %( indiceActuelListe )
self.lock.release()
# On en lance un
threading.Thread( target = ajoutPage,
args = ( self, listeURL[ indiceActuelListe ] )
).start()
indiceActuelListe += 1
#~ self.lock.release()
#~ time.sleep( 0.01 ) # Legere attente pour que le thread ait le temps d'incrementer le nombre de threads lances
else: # Sinon,
# On attend un peu avant de reessayer
self.lock.release()
time.sleep( 0.1 )
#~ print self.nbThreadLances
self.lock.acquire()
self.lock.release()
# Boucle pour attendre la fin de tous les threads
self.lock.acquire()
while( self.nbThreadLances > 0 ): # Si des threads ne sont pas finis
#~ print self.nbThreadLances
# On attend un peu
self.lock.release()
time.sleep( 0.1 )
self.lock.acquire()
self.lock.release()
return self.listePage
## Methode pour recuperer une image
# @param URLPicture URL de l'image a charger
# @return Image
def getPicture( self, URLPicture ):
logger.info( "acces a l'image %s" %( URLPicture ) )
try:
# Image a charger
page = self.navigateur.open( URLPicture, timeout = self.timeOut )
# Donnees de l'image
donnees = page.read()
return donnees
except urllib2.URLError, erreur:
try:
logger.error( erreur.reason )
except :
pass
return ""
def unescape( self, texte ):
#~ def ent2chr( m ):
#~ code = m.group( 1 )
#~ if( code.isdigit() ):
#~ code = int( code )
#~ else:
#~ code = int( code[ 1 : ], 16 )
#~ if( code < 256 ):
#~ return chr( code )
#~ else:
#~ return '?'
#~
#~ texte = texte.replace( "<", "<" )
#~ texte = texte.replace( ">", ">" )
#~ texte = texte.replace( "&", "&" )
#~ texte = texte.replace( """, '"' )
#~ texte = texte.replace( "'", "'" )
#~ texte = re.sub( r'\&\#(x?[0-9a-fA-F]+);', ent2chr, texte )
return xml.sax.saxutils.unescape( texte )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os
import os.path
import threading
import subprocess
import shlex
import re
import fcntl
import select
import time
import sys
import unicodedata
import logging
logger = logging.getLogger( __name__ )
from Preferences import Preferences
from fonctions.urlToRtmpdump import urlToRtmpdump
##########
# Classe #
##########
## Classe qui gere le telechargement des fichiers
class Downloader( object ):
# Instance de la classe (singleton)
instance = None
## Surcharge de la methode de construction standard (pour mettre en place le singleton)
def __new__( self, *args, **kwargs ):
if( self.instance is None ):
self.instance = super( Downloader, self ).__new__( self )
return self.instance
## Constructeur
# @param signaux Lanceur de signaux. Si on le precise pas, aucun signal n'est lance (mode CLI).
def __init__( self, signaux = None ):
self.preferences = Preferences()
self.signaux = signaux
self.arreter = True
self.process = None
## Methode pour afficher un pourcentage à l'ecran
# @param pourcentage Pourcentage actuel a afficher
def afficherPourcentage( self, pourcentage ):
# On s'assure que le pourcentage soit bien entre 0 et 100
if( pourcentage < 0 ):
pourcentage = 0
elif( pourcentage > 100 ):
pourcentage = 100
message = str( pourcentage ) + " %"
print '\r', # Permet d'écrire au même endroit
sys.stdout.write( message )
sys.stdout.flush()
## Methode pour lancer le telecharger des fichiers
# @param listeFichiers Liste des fichiers a telecharger
def lancerTelechargement( self, listeFichiers ):
self.arreter = False
for ( numero, fichier, nomFichierSortie ) in listeFichiers:
logger.info( u"téléchargement de %s" %( fichier ) )
# Si on demande de s'arreter, on sort
if self.arreter:
break
# Si on a le lanceur de signal
if self.signaux :
# On envoie le signal de debut de telechargement d'un fichier
self.signaux.signal( "debutTelechargement", numero )
else:
print "Debut telechargement", nomFichierSortie
# On ajoute le repertoire de destination au nom du fichier
fichierSortie = self.preferences.getPreference( "repertoireTelechargement" ) + "/" + nomFichierSortie
# On telecharge de differentes manieres selon le protocole
if( fichier[ :4 ] == "rtmp" ):
commande = urlToRtmpdump( fichier )
self.telecharger( commande + " -o \"" + fichierSortie + "\"" )
elif( fichier[ :4 ] == "http" or fichier[ :3 ] == "ftp" or fichier[ :3 ] == "mms" ):
self.telecharger( "msdl -c " + fichier + " -o \"" + fichierSortie + "\"" )
else:
logger.warn( "le protocole du fichier %s n'est pas gere" %( fichier ) )
# Si on a le lanceur de signal
if self.signaux :
# On envoie le signal de fin de telechargement d'un fichier
self.signaux.signal( "finTelechargement", numero )
else:
print "\n\tFin telechargement"
# Si on a le lanceur de signal
if self.signaux :
# On envoie le signal de fin de telechargement des fichiers
self.signaux.signal( "finDesTelechargements" )
## Methode qui telecharge un fichier
# @param commande Commande a lancer pour telecharger le fichier
def telecharger( self, commande ):
# Commande mise au bon format pour Popen
if( not isinstance( commande, str ) ):
commande = str( commande )
arguments = shlex.split( commande )
# On lance la commande en redirigeant stdout et stderr (stderr va dans stdout)
self.process = subprocess.Popen( arguments, stdout = subprocess.PIPE, stderr = subprocess.STDOUT )
# On recupere le flux stdout
stdoutF = self.process.stdout
# On recupere le descripteur de fichier de stdout
stdoutFD = stdoutF.fileno()
# On recupere les flags existants
stdoutFlags = fcntl.fcntl( stdoutFD, fcntl.F_GETFL )
# On modifie les flags existants en ajoutant le flag NoDelay
fcntl.fcntl( stdoutFD, fcntl.F_SETFL, stdoutFlags | os.O_NDELAY )
# Tant que le subprocess n'est pas fini
while( self.process.poll() == None ):
# On attent que stdout soit lisible
if( stdoutFD in select.select( [ stdoutFD ],[],[] )[ 0 ] ):
# On lit stdout
ligne = stdoutF.read()
# On affiche que les textes non vides
if ligne:
pourcentListe = re.findall( "(\d{1,3}\.{0,1}\d{0,1})%", ligne )
if( pourcentListe != [] ):
pourcent = int( float( pourcentListe[ -1 ] ) )
if( pourcent >= 0 and pourcent <= 100 ):
# Si on a le lanceur de signal
if not self.signaux :
self.afficherPourcentage( pourcent )
elif self.signaux :
# On envoit le pourcentage d'avancement a l'interface
self.signaux.signal( "pourcentageFichier", pourcent )
# On attent avant de recommencer a lire
time.sleep( 3 )
## Methode pour stopper le telechargement des fichiers
def stopperTelechargement( self ):
if not self.arreter:
# On sort de la boucle principale
self.arreter = True
# On stop le process s'il est lance
if( self.process.poll() == None ):
self.process.terminate()
#~ self.process.kill()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier LICENSE #
#########################################
#~ Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
#~ Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
#~ Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os,os.path,pickle
from API import API
from Option import Option
import logging
logger = logging.getLogger( __name__ )
import Constantes
##########
# Classe #
##########
## Classe abstraite Plugin dont doit heriter chacun des plugins.
#
# Les plugins doivent hériter de cette classe et redéfinir les méthodes #listerChaines, #listerEmissions et #listerFichiers.
# La méthode #listerOptions est optionnellement à redéfinir (dans le cas où il y aurai des options).
class Plugin(object):
## @var API
# Instance de l'API à utilisé pour l'accès au méthode de l'API.
## @var nom
# Nom du plugin
## @var url
# Url du site internet du plugin
## @var frequence
# Nombre de jour avant le rafraichissement automatique du plugin
## @var fichierConfiguration
# Chemin du fichier de configuration
## @var fichierCache
# Chemin du fichier de cache
## Constructeur
# @param self le plugin courant
# @param nom le nom du plugin
# @param url l'url du site internet
# @param frequence la fréquence (en jour) de rafraichissement, 0 pour ne jamais rafraichir
def __init__(self, nom=None, url=None, frequence=7):
self.API = API.getInstance()
self.pluginDatas = {"chaines":[],
"emissions":{},
"fichiers":{}}
self.pluginOptions = []
if nom == None:
logger.warn("DEPRECATED: il faut préciser le nom du plugin au constructeur")
else:
self.nom = nom
if url == None:
logger.warn("DEPRECATED: il faut préciser l'url du site du plugin au constructeur")
else:
self.url = url
self.frequence = frequence
self.fichierConfiguration = os.path.join( Constantes.REPERTOIRE_CONFIGURATION, self.nom.replace( " ", "_" )+ ".conf" )
self.fichierCache = os.path.join( Constantes.REPERTOIRE_CACHE, self.nom.replace( " ", "_" ) + ".cache" )
## Efface les informations mémorisées.
# @param self l'objet courant
def vider(self):
self.pluginDatas = {"chaines":[],
"emissions":{},
"fichiers":{}}
self.pluginOptions = []
## Effectue le listage des options.
# Utiliser #optionTexte, #optionCheckbox, #optionListeMultiple et #optionListeUnique pour ajouter des options
# @param self le plugin courant
# @return rien
def listerOptions(self):
pass
## Rafraichie les informations durable du plugins comme la liste des émissions.
# Y placer les traitements lourd n'ayant pas besoin d'être fait souvent.
# @param self le plugin courant
# @return Rien
def rafraichir( self ):
pass
## Effectue le listage des chaînes.
# Utiliser #ajouterChaine pour ajouter une chaîne à la liste.
# @param self le plugin courant
# @return rien
def listerChaines( self ):
pass
## Effectue le listage des émissions.
# Utiliser #ajouterEmission pour ajouter une émission à la liste.
# @param self le plugin courant
# @param chaine la chaine
# @return rien
def listerEmissions( self, chaine ):
pass
## Effectue le listage des fichiers.
# Utiliser #ajouterFichier pour ajouter un fichier à la liste.
# @param self le plugin courant
# @param emission l'emission
# @return Rien
def listerFichiers( self, emission ):
pass
## Ajoute une chaine à celle disponible pour ce plugin.
# A utiliser dans #listerChaines et en remplacement d'un retour de paramètre.
# @param self le plugin courant
# @param chaine le nom de la chaine
# @return Rien
def ajouterChaine(self, chaine):
self.pluginDatas["chaines"].append(chaine)
## Ajoute une émission à celle disponible pour ce plugin.
# A utiliser dans #listerEmissions et en remplacement d'un retour de paramètre.
# @param self le plugin courant
# @param chaine le nom de la chaine de l'émission
# @param emission le nom de l'émission
# @return Rien
def ajouterEmission(self, chaine, emission):
if not self.pluginDatas["emissions"].has_key(chaine):
self.pluginDatas["emissions"][chaine] = []
self.pluginDatas["emissions"][chaine].append(emission)
## Ajoute un fichier à ceux disponible pour ce plugin.
# A utiliser dans #listerFichiers et en remplacement d'un retour de paramètre.
# @param self le plugin courant
# @param emission l'emission du fichier
# @param fichier le fichier
# @return Rien
def ajouterFichier(self, emission, fichier):
if not self.pluginDatas["fichiers"].has_key(emission):
self.pluginDatas["fichiers"][emission] = []
self.pluginDatas["fichiers"][emission].append(fichier)
## Affiche le texte "text" dans la console avec en préfixe le nom du plugin.
# Facilite le déboguage, utilisé cette méthode plutôt que "print".
# @param self le plugin courant
# @param text le texte à afficher en console
# @param ligne paramètre inutile, conservé par rétrocompatibilité
# @return Rien
def afficher(self, text, ligne=None):
if ligne != None:
logger.warn("Le paramètre ligne n'a plus aucun effet.")
logger.info(self.nom+":"+text)
## Sauvegarde les options.
#
# Sauvegarde les options dans le fichier de configuration, ne pas utiliser.
# Les options sont sauvegardées automatiquement.
# @param self le plugin courant
# @return Rien
# @deprecated Ne fait plus rien. Ne pas uiliser.
def sauvegarderPreference(self):
logger.warn("Plugin.sauvegarderPreference(): DEPRECATED: ne fait plus rien.")
return
try:
file = open(self.fichierConfiguration, "w")
pickle.dump(self.pluginOptions, file)
file.close()
except:
print "Plugin.sauvegarderPreference(): Erreur de sauvegarde"
## Charge les préférences.
#
# Charge les préférences du fichier de configuration, ne pas utiliser.
# Les options sont chargées automatiquement.
# @param self le plugin courant
# @return Rien
# @deprecated Ne fait plus rien. Ne pas uiliser.
def chargerPreference(self):
logger.warn("Plugin.chargerPreference(): DEPRECATED: ne fait plus rien.")
return
if os.path.exists(self.fichierConfiguration):
try:
file = open(self.fichierConfiguration, "r")
tmp = pickle.load(file)
file.close()
self.pluginOptions = tmp
except:
print "Plugin.chargerPreference(): Erreur de chargement"
## Sauvegarde un objet dans le cache.
#
# Attention, cette méthode écrase le cache déjà enregistré.
# @param self le plugin courant
# @param objet l'objet à sauvegarder
# @return Rien
def sauvegarderCache(self, objet):
try:
file = open(self.fichierCache, "w")
pickle.dump(objet, file)
file.close()
except:
logger.error("Plugin.sauvegarderCache(): Erreur de sauvegarde")
## Charge le fichier de cache.
# @param self le plugin courant
# @return l'objet sauvegardé dans le cache ou None en cas d'échec
def chargerCache(self):
if os.path.exists(self.fichierCache):
try:
file = open(self.fichierCache, "r")
tmp = pickle.load(file)
file.close()
return tmp
except:
return None
else:
return None
## Renvoie la valeur d'une option
#
# L'option doit être ajouter dans #listerOptions pour que cela renvoie une valeur.
# @param self le plugin courant
# @param nom le nom de l'option
# @return la valeur de l'option, None en cas d'échec
def getOption(self, nom):
for option in self.pluginOptions:
if option.getNom() == nom:
return option.getValeur()
return None
## Ajoute une option texte.
# @param self le plugin courant
# @param nom le nom de l'option (sert d'identifiant)
# @param description la description de l'option
# @param defaut la valeur par défaut (celle qui sera présente lors de l'affichage des options)
# @return rien
def optionTexte(self, nom, description, defaut):
self.pluginOptions.append(Option(Option.TYPE_TEXTE, nom, description, defaut))
## Ajoute une option bouléen.
# @param self le plugin courant
# @param nom le nom de l'option (sert d'identifiant)
# @param description la description de l'option
# @param defaut la valeur par défaut, True pour coché, faut pour décoché
# @return rien
def optionBouleen(self, nom, description, defaut):
self.pluginOptions.append(Option(Option.TYPE_BOULEEN, nom, description, defaut))
## Ajoute une option liste (choix multiple).
# @param self le plugin courant
# @param nom le nom de l'option (sert d'identifiant)
# @param description la description de l'option
# @param valeurs les valeurs possibles (liste)
# @param defauts les valeurs sélectionnées (liste)
# @return rien
def optionChoixMultiple(self, nom, description, defauts, valeurs):
self.pluginOptions.append(Option(Option.TYPE_CHOIX_MULTIPLE, nom, description, defauts, valeurs))
## Ajoute une option liste (choix unique).
# @param self le plugin courant
# @param nom le nom de l'option (sert d'identifiant)
# @param description la description de l'option
# @param valeurs les valeurs possibles (liste)
# @param defaut la valeur par défaut
# @return rien
def optionChoixUnique(self, nom, description, defaut, valeurs):
self.pluginOptions.append(Option(Option.TYPE_CHOIX_UNIQUE, nom, description, defaut, valeurs))
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os
import pickle
import logging
logger = logging.getLogger( __name__ )
import Constantes
from GUI.Downloader import Downloader
from Navigateur import Navigateur
from PluginManager import PluginManager
##########
# Classe #
##########
## Classe qui gere les preferences du logiciel
class Preferences( object ):
# Instance de la classe (singleton)
instance = None
## Surcharge de la methode de construction standard (pour mettre en place le singleton)
def __new__( self, *args, **kwargs ):
if( self.instance is None ):
self.instance = super( Preferences, self ).__new__( self )
return self.instance
## Constructeur
def __init__( self ):
self.pluginManager = PluginManager()
self.fichierConfiguration = Constantes.FICHIER_CONFIGURATION_TVD
self.chargerConfiguration()
## Methode qui charge les preferences du logiciel
def chargerConfiguration( self ):
# Parametres par defaut
self.preferencesParDefault = { "repertoireTelechargement" : Constantes.REPERTOIRE_TELECHARGEMENT_DEFAUT,
"pluginsActifs" : [],
"pluginParDefaut" : "",
"tailleFenetre" : [ 500, 500 ],
"timeOut" : 15,
"nbThreadMax" : 20
}
if os.path.exists( self.fichierConfiguration ): # Si le fichier existe, on le charge
# On recupere les preferences dans le fichier
fichier = open( self.fichierConfiguration, "r" )
self.preferences = pickle.load( fichier )
fichier.close()
# On verifie qu'il ne nous manque pas une preference
# Si c'est le cas, on prend sa valeur par defaut
for elmt in self.preferencesParDefault.keys():
if not self.preferences.has_key( elmt ):
self.preferences[ elmt ] = self.preferencesParDefault[ elmt ]
else: # Sinon, on utilise les parametres par defaut
self.preferences = self.preferencesParDefault
# On active les plugins qui doivent etre actifs
for plugin in self.preferences[ "pluginsActifs" ]:
self.pluginManager.activerPlugin( plugin )
# On cree le repertoire de telechargement s'il n'existe pas
if( not os.path.isdir( self.preferences[ "repertoireTelechargement" ] ) ):
os.makedirs( self.preferences[ "repertoireTelechargement" ] )
# On applique les preferences
self.appliquerPreferences()
## Methode qui applique les preferences
def appliquerPreferences( self ):
Downloader.repertoireTelechargement = self.preferences[ "repertoireTelechargement" ]
Navigateur.timeOut = self.preferences[ "timeOut" ]
Navigateur.maxThread = self.preferences[ "nbThreadMax" ]
## Methode qui sauvegarde les preferences du logiciel
def sauvegarderConfiguration( self ):
# On applique les preferences
self.appliquerPreferences()
# On sauvegarde les preferences dans le fichier de configuration
fichier = open( self.fichierConfiguration, "w" )
pickle.dump( self.preferences, fichier )
fichier.close()
## Methode qui renvoit une preference du logiciel
# @param nomPreference Nom de la preference a renvoyer
# @return Valeur de cette preference
def getPreference( self, nomPreference ):
try:
return self.preferences[ nomPreference ]
except KeyError:
logger.warn( "preference %s inconnue" %( nomPreference ) )
return None
## Methode qui met en place la valeur d'une preference
# @param nomPreference Nom de la preference dont on va mettre en place la valeur
# @param valeur Valeur a mettre en place
def setPreference( self, nomPreference, valeur ):
# Si on sauvegarde une nouvelle liste de plugin
if( nomPreference == "pluginsActifs" ):
nouvelleListe = valeur
ancienneListe = self.preferences[ "pluginsActifs" ]
# Pour chaque element dans l'union des 2 listes
for elmt in ( set( nouvelleListe ).union( set( ancienneListe ) ) ):
if( ( elmt in ancienneListe ) and not ( elmt in nouvelleListe ) ):
self.pluginManager.desactiverPlugin( elmt )
elif( ( elmt in nouvelleListe ) and not ( elmt in ancienneListe ) ):
self.pluginManager.activerPlugin( elmt )
# Dans tous les cas, on sauvegarde la preference
self.preferences[ nomPreference ] = valeur
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import logging
import optparse
import os
import sys
import Constantes
#
# Entree du programme
#
if __name__ == "__main__" :
# On se deplace dans le repertoire de travail (pas necessaire sous Windows)
if( not Constantes.OS_WINDOWS ):
# On se deplace dans le repertoire de travail du logciel
repertoireTravail = os.path.dirname( os.path.abspath( __file__ ) )
sys.path.insert( 0, repertoireTravail )
os.chdir( repertoireTravail )
# Options a parser
parser = optparse.OptionParser()
parser.add_option( "-v", "--verbose",
action = "store_true", dest = "verbose", default = False,
help = "Affiche informations dans le terminal" )
parser.add_option( "-c", "--cli",
action = "store_true", dest = "cli", default = False,
help = "Affiche la version CLI" )
parser.add_option( "-d", "--dialog",
action = "store_true", dest = "dialog", default = False,
help = u"Affiche la version Dialog (en cours de développement)" )
parser.add_option( "-g", "--genererXML",
action = "store_true", dest = "genererXML", default = False,
help = u"Génère le fichier XML qui decrit les plugins" )
options, args = parser.parse_args()
# On a active le mode verbeux ?
logger = logging.getLogger( __name__ )
console = logging.StreamHandler( sys.stdout )
if( options.verbose ):
logger.setLevel( logging.DEBUG )
console.setLevel( logging.DEBUG )
else:
logger.setLevel( logging.ERROR )
console.setLevel( logging.ERROR )
console.setFormatter( logging.Formatter( '%(levelname)-7s %(name)s : %(message)s' ) )
logger.addHandler( console )
# On veut generer le fichier XML qui decrit les plugins
if( options.genererXML ):
import UpdateManager
UpdateManager.UpdateManager.creerXML()
sys.exit( 0 )
# On met en place les repertoires de travail du logiciel
repertoires = [ Constantes.REPERTOIRE_CACHE, \
Constantes.REPERTOIRE_CONFIGURATION, \
Constantes.REPERTOIRE_LOGS, \
Constantes.REPERTOIRE_PLUGIN_PERSO ]
for repertoire in repertoires:
if( not os.path.isdir( repertoire ) ):
logger.info( "création du répertoire %s" %( repertoire ) )
os.makedirs( repertoire )
# On demarre le CLI ou le GUI ?
if( options.cli == False and options.dialog == False ):
# On importe les fichiers necessaires pour le GUI
try:
from PyQt4 import QtGui
except ImportError:
logger.critical( "ouuupppss : il vous faut PyQt4 pour pouvoir utiliser ce programme..." )
sys.exit( 1 )
from GUI.MainWindow import MainWindow
# On creer l'interface graphique
app = QtGui.QApplication( sys.argv )
window = MainWindow()
window.show()
sys.exit( app.exec_() )
elif( options.cli == True ):
from CLI.cli import cli
cli()
else:
from CLIDialog.CLIDialog import CLIDialog
CLIDialog()
| Python |
#/usr/bin/python
# -*- coding: utf-8 -*-
import os
#classe qui affiche la barre en haut de l'ecran
# @param self l'objet courant
# @param plugin le nom du plugin choisi
# @param chaine le nom de la chaine choisie
# @param program le nom du programme choisi
# @param program le nom du programme choisi ou de l'ecran d'option affiche
# @return Rien
def header(plugin,chaine,program):
print ""
#on efface l'affichage en cours
os.system(['clear','cls'][os.name == 'nt'])
#formatte le nom du plugin (entre 0 et 14 caracteres)
if len(plugin)<7:plugin+="\t"
#formatte le nom de la chaine (entre 0 et 14 caracteres)
if len(chaine)<7:chaine+="\t"
#formatte le nom du programme selon le nombre de caracteres
#if len(program)==0:program+="\t\t\t\t "
if len(program)<=7:program+= "\t\t\t\t "
elif len(program)<=14:program+="\t\t\t "
elif len(program)<=21:program+= "\t\t "
elif len(program)<=28:program+= "\t "
elif len(program)<=36:program+= " "
elif len(program)>36:
program=program[:33]
program+="..."
#affiche la barre avec les parametres recus
print " ##############################################################################"
print " ## TVDownloader 0.4 ##"
print " ## Command-Line Interface ##"
print " ## ##"
print " ## ##"
print " ##\t",plugin,"\t",chaine,"\t",program,"##"
print " ## ##"
print " ##############################################################################"
print ""
#classe qui affiche la barre de menu en bas de l'ecran, avant l'invite de saisie
# @param self l'objet courant
# @param Rien
# @return Rien
def footer():
print " q:quitter p:preferences t:telechargements r:retour a:actualiser",
#classe qui affiche les plugins, avec defilement +/- si plus de 15 plugins
# @param self l'objet courant
# @param plugins la liste des plugins
# @param current le numero de defilement dans la liste (0 pour la premiere page, 1 pour la page suivantee, etc)
# @return Rien
def plugin(plugins,current):
for i in range(10) :
if i+10*current<len(plugins): print " ",i,":",plugins[i+10*current]
else: print ""
print "\n\n"
if len(plugins)>10:print " +:plugins suivants -:plugins precedents (page",current+1,"/",len(plugins)/10+1,",",len(plugins),"plugins)"
else:print""
#classe qui affiche les chaines, avec defilement +/- si plus de 15 chaines
# @param self l'objet courant
# @param chaines la liste des chaines
# @param current le numero de defilement dans la liste (0 pour la premiere page, 1 pour la page suivantee, etc)
# @return Rien
def chaine(chaines,current):
for i in range(10) :
if i+10*current<len(chaines): print " ",i,":",chaines[i+10*current]
else: print ""
print "\n\n"
if len(chaines)>10:print " +:chaines suivantes -:chaines precedentes (page",current+1,"/",len(chaines)/10+1,",",len(chaines),"chaines)"
else:print""
#classe qui affiche les programmes, avec defilement +/- si plus de 15 programmes
# @param self l'objet courant
# @param programs la liste des programmes
# @param current le numero de defilement dans la liste (0 pour la premiere page, 1 pour la page suivantee, etc)
# @return Rien
def program(programs,current):
for i in range(10) :
if i+10*current<len(programs): print " ",i,":",programs[i+10*current]
else: print ""
print "\n\n"
if len(programs)>10:print " +:programmes suivants -:programmes precedents (page",current+1,"/",len(programs)/10+1,",",len(programs),"programmes)"
else:print""
#classe qui affiche les fichiers, avec defilement +/- si plus de 15 fichiers
# @param self l'objet courant
# @param fichiers la liste des fichiers
# @param current le numero de defilement dans la liste (0 pour la premiere page, 1 pour la page suivantee, etc)
# @return Rien
def fichier(fichiers,current):
for i in range(10) :
if i+10*current<len(fichiers):
if len(fichiers[i+10*current].nom)>74:print " ",i,":",fichiers[i+10*current].nom[:71]+"..."
elif len(fichiers[i+10*current].nom)<=74: print " ",i,":",fichiers[i+10*current].nom
else: print ""
print "\n\n"
if len(fichiers)>10:print " +:fichiers suivants -:fichiers precedents (page",current+1,"/",len(fichiers)/10+1,",",len(fichiers),"fichiers)"
else:print""
print " *:tous ",
| Python |
#/usr/bin/python
# -*- coding: utf-8 -*-
import os
import sys
import time
from CLI.Option import dl,prefs,quitter,wait,info
from CLI.Screen import header,footer,plugin,chaine,program,fichier
from getch import getch
from API import API
from APIPrive import APIPrive
from PluginManager import PluginManager
from Preferences import Preferences
from Downloader import Downloader
class show:
def __init__(self,selectedPlugin,selectedChaine,selectedProgram,temp):
#affichage de la barre du programme en haut de l'ecran
header(selectedPlugin,selectedChaine,selectedProgram)
#selon l'avancement dans la navigation on affichage les plugins, chaines, programmes ou fichiers
if len(selectedPlugin)==0:
plugin(plugins,temp)
elif len(selectedChaine)==0:
chaine(chaines,temp)
elif len(selectedProgram)==0:
program(programs,temp)
elif len(selectedPlugin)!=0 and len(selectedChaine)!=0 and len(selectedProgram)!=0:
fichier(fichiers,temp)
footer()
class cli:
def __init__(self):
#declaration des variables
global choice, temp, plugins, chaines, programs, fichiers, DLlist
chaines=''
programs=''
fichiers=''
temp = 0
choice = ""
selectedPlugin =''
selectedChaine =''
selectedProgram = ''
DLlist=[]
################################################
# Instanciations + initialisation de variables #
################################################
# On instancie le plugin manager
self.pluginManager = PluginManager()
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# On instancie le gestionnaire de download
self.downloader = Downloader()
# On recupere l'instance de API
self.api = API.getInstance()
# # On instancie le gestionnaire d'historique
# self.historique = Historique()
# Si aucun plugin n'est active, on ouvre la fenetre des preferences
if( len( self.preferences.getPreference( "pluginsActifs" ) ) == 0 ):
choice = 'p'
self.api.pluginRafraichirAuto()
# On met en place la liste des plugins dans API
plugins = self.preferences.getPreference( "pluginsActifs" )
plugins.sort()
# On actualise tous les plugins
self.api.pluginRafraichirAuto()
#boucle qui raffraichit l'affichage apres chaque interaction utilisateur
while choice != 'exit':
#ouverture du menu de preferences
if choice == 'p' or choice == 'P':
prefs()
# On met en place la liste des plugins dans API
plugins = self.preferences.getPreference( "pluginsActifs" )
plugins.sort()
# On actualise tous les plugins
self.api.pluginRafraichirAuto()
#ouverture du menu de telechargement
elif choice == 't' or choice == 'T': dl(DLlist)
#ouverture de l'invite de fermeture
elif choice == 'q' or choice == 'Q': quitter()
#actualisation de l'affichage ecran
elif choice == 'i' or choice == 'I': info()
#actualisation de l'affichage ecran
elif choice == 'a' or choice == 'A':
header(selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\t\tRafraichissement\n\n\n"
self.api.pluginRafraichirAuto()
#recharger les listes
if len(selectedProgram)!=0:
fichiers = self.api.getPluginListeFichiers(selectedPlugin,selectedProgram)
elif len(selectedChaine)!=0:
programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine)
elif len(selectedPlugin)!=0:
chaines = self.api.getPluginListeChaines(selectedPlugin)
elif len(selectedPlugin)==0 and len(selectedChaine)==0 and len(selectedProgram)==0:
plugins = self.preferences.getPreference( "pluginsActifs" )
plugins.sort()
#mise a jour de l'affichage
header(selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\t\tVeuillez patientez pendant la mise a jour des informations\n\n\n"
time.sleep(1)
show(selectedPlugin,selectedChaine,selectedProgram,temp)
elif choice == 'r' or choice == 'R':
temp=0
if len(selectedProgram)!=0:
selectedProgram=""
elif len(selectedChaine)!=0:
selectedChaine=""
if len(chaines)==1:
selectedPlugin=""
elif len(selectedPlugin)!=0:
selectedPlugin=""
elif choice.isdigit() and int(choice)>=0:
choice=10*temp+int(choice)
if len(selectedPlugin)==0 and len(plugins)>choice:
temp=0
selectedPlugin = plugins[choice]
chaines = self.api.getPluginListeChaines(selectedPlugin)
if len(chaines)==1:
header(selectedPlugin,'','')
print "Une seule chaine :",chaines
time.sleep (0.5)
selectedChaine=chaines[0]
programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine)
elif len(selectedChaine)==0 and len(chaines)>choice:
temp=0
selectedChaine=chaines[choice]
programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine)
elif len(selectedProgram)==0 and len(programs)>choice:
selectedProgram=programs[choice]
header(selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\t\tVeuillez patientez pendant le chargement des informations\n\n\n"
fichiers = self.api.getPluginListeFichiers(selectedPlugin,selectedProgram)
if len(fichiers)==0:
header (selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\n\n\n\t\tAucun fichier dans le programme :",selectedProgram
time.sleep (1)
selectedProgram=''
else:temp=0
elif len(selectedPlugin)!=0 and len(selectedChaine)!=0 and len(selectedProgram)!=0 and len(fichiers)>choice:
header(selectedPlugin,selectedChaine,selectedProgram)
if fichiers[choice] not in DLlist:
print "\n\n\n\n\n\n\najout",fichiers[choice].nom,"a la liste de telechargement\n\n\n\n\n\n\n\n\n"
DLlist.append(fichiers[choice])
else: print "\n\n\n\n\n\n\n\t\tFichier deja dans la liste de telechargement\n\n\n\n\n\n\n\n\n"
time.sleep(1)
os.system(['clear','cls'][os.name == 'nt'])
elif choice=='*':
# if len(selectedPlugin)==0:
# temp=0
# selectedPlugin = 'None'
# chaines = self.api.getPluginListeChaines()
# elif len(selectedChaine)==0:
# temp=0
# selectedChaine='None'
# programs = self.api.getPluginListeEmissions(selectedPlugin,selectedChaine)
# el
if len(selectedProgram)==0:
selectedProgram='Tous'
header(selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\t\tVeuillez patientez pendant le chargement des informations\n\n\n"
# for choice in range(len(programs)) :
fichiers = self.api.getPluginListeFichiers(selectedPlugin,None)#programs[choice])
elif len(selectedPlugin)!=0 and len(selectedChaine)!=0 and len(selectedProgram)!=0:
header(selectedPlugin,selectedChaine,selectedProgram)
for choice in range(len(fichiers)) :
if fichiers[int(choice)] not in DLlist:
header(selectedPlugin,selectedChaine,selectedProgram)
print "\n\n\n\n\t\tajout",fichiers[int(choice)].nom,"a la liste de telechargement"
DLlist.append(fichiers[int(choice)])
else: print "\t\tFichier deja dans la liste de telechargement"
time.sleep(0.5)
#afficher la suite de la liste
elif choice=='+':
if len(selectedPlugin) == 0:
if len(plugins)>temp*10+10: temp+=1
elif len(selectedChaine) == 0:
if len(chaines)>temp*10+10: temp+=1
elif len(selectedProgram) == 0:
if len(programs)>temp*10+10: temp+=1
elif len(selectedPlugin) != 0 and len(selectedChaine) != 0 and len(selectedProgram) != 0:
if len(fichiers)>temp*10+10: temp+=1
#afficher le debut de la liste
elif choice=='-':
if temp!=0: temp-=1
show(selectedPlugin,selectedChaine,selectedProgram,temp)
choice=''
# if not choice:choice=raw_input("\n\t\tEntrez votre choix : ")
if not choice:choice=getch()
# if len(choice)>1:choice=choice[0]
# if choice:print choice[0]
#split
if __name__=="__main__":
main()
| Python |
#/usr/bin/python
# -*- coding: utf-8 -*-
import os
import sys
import time
from CLI.Screen import header,footer
from Downloader import Downloader
from Preferences import Preferences
from Historique import Historique
from getch import getch
class dl:
def __init__(self, DLlist):
# On instancie le gestionnaire de preferences et sa fenetre
self.preferences = Preferences()
# On instancie le gestionnaire de download
self.downloader = Downloader()
# On instancie le gestionnaire d'historique et sa fenetre
self.historique = Historique()
current=0
global choice
choice=''
while choice!='r' and choice!='R':
if choice=='s' or choice=='S':
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\tSupprimer tous les fichiers de la liste de telchargement"
#pour chaque fichier de la liste ***(len(DLlist))!=0
while len(DLlist)>0:
print "Supprimer le fichier :",DLlist[0].nom
#supprimer le fichier de la liste
DLlist.remove(DLlist[0])
#ajouter le fichier au log
time.sleep (1)
if choice=='t' or choice=='T':
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\ttelecharger tous les fichiers"
#pour chaque fichier de la liste ***(len(DLlist))!=0
while len(DLlist)>0:
if not self.historique.comparerHistorique(DLlist[0]):
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\ttelecharger le fichier :",DLlist[0].nom
if(DLlist[0].nomFichierSortie=="" ):
DLlist[0].nomFichierSortie=os.path.basename(getattr(DLlist[0],"lien" ))
#telecharger le fichier
self.downloader.lancerTelechargement([[0,DLlist[0].lien,DLlist[0].nomFichierSortie]])
#ajouter le fichier a l'historique de telechargement
self.historique.ajouterHistorique(DLlist[0])
else:
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\tFichier deja telecharge"
#supprimer le fichier de la liste
DLlist.remove(DLlist[0])
time.sleep (1)
elif choice=='q' or choice=='Q':
quitter()
elif choice.isdigit() and len(DLlist)>int(choice)+10*current and int(choice)>=0:
value=''
while (value!='r' and value!='t' and value!='s'):
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\tFichier :",DLlist[int(choice)+10*current].nom,"\n\n\tQue voulez vous faire?\n\n\t\tt:telecharger le fichier\n\t\ts:supprimer le fichier de la liste de telechargement\n\t\tr:retour a liste de telechargement\n\n\n\n\n"
value=getch()
if value=='t':
if not self.historique.comparerHistorique(DLlist[int(choice)+10*current]):
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\ttelecharger le fichier :",DLlist[int(choice)].nom
# Si le nom du fichier de sortie n'existe pas, on l'extrait de l'URL
if(DLlist[int(choice)+10*current].nomFichierSortie=="" ):
DLlist[int(choice)+10*current].nomFichierSortie=os.path.basename(getattr(DLlist[int(choice)+10*current],"lien" ))
#telecharger le fichier
self.historique.ajouterHistorique(DLlist[int(choice)+10*current])
self.downloader.lancerTelechargement([[0,DLlist[int(choice)].lien,DLlist[int(choice)].nomFichierSortie]])
#ajouter le fichier a l'historique de telechargement
else:
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\tFichier deja telecharge"
time.sleep(1)
#supprimer le fichier de la liste
DLlist.remove(DLlist[int(choice)])
elif value=='s':
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\tSuppression de la liste de telechargement du fichier :\n\n\t\t",DLlist[int(choice)].nom
#supprimer le fichier de la liste
DLlist.remove(DLlist[int(choice)])
elif value=='r':
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\tRetour a la liste de telechargement"
#ajouter le fichier au log
time.sleep(1)
elif choice=='*' :
value=''
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\n\n\tQue voulez vous faire?\n\n\t\tt:telecharger les fichiers\n\t\ts:supprimer les fichiers de la liste de telechargement\n\n\n\n\n\n"
value=getch()
while len(DLlist)>0:
if value=='t':
if not self.historique.comparerHistorique(DLlist[0]):
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\ttelecharger le fichier :",DLlist[0].nom
# Si le nom du fichier de sortie n'existe pas, on l'extrait de l'URL
if(DLlist[0].nomFichierSortie=="" ):
DLlist[0].nomFichierSortie=os.path.basename(getattr(DLlist[0],"lien" ))
#telecharger le fichier
self.downloader.lancerTelechargement([[0,DLlist[0].lien,DLlist[0].nomFichierSortie]])
#ajouter le fichier a l'historique de telechargement
self.historique.ajouterHistorique(DLlist[0])
else:
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\tFichier deja telecharge"
time.sleep(0.5)
#supprimer le fichier de la liste
DLlist.remove(DLlist[0])
#ajouter le fichier au log
elif choice=='+':
if len(DLlist)>current*10+10: current+=1
elif choice=='-':
if current!=0: current-=1
choice=''
#sauvegarder l'historique de telechargement
self.historique.sauverHistorique()
#affichage a l'ecran de la liste
header ('','','Liste de telechargement\t')
for i in range(10):
if len(DLlist)>i+10*current:
if len(DLlist[int(i+10*current)].nom)>74: print " ",i,":",DLlist[int(i+10*current)].nom[:71]+"..."
elif len(DLlist[int(i+10*current)].nom)<=74: print " ",i,":",DLlist[int(i+10*current)].nom
else: print ""
if len(DLlist)>10:print "\n\t+:fichiers suivants\t-:fichiers precedents (page",current+1,"/",len(DLlist)/10+1,",",len(DLlist),"chaines)"
else:print"\n"
print "\n\tt:telecharger tous les fichiers s:supprimer tous les fichiers"
footer()
if len(DLlist)==0:
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Liste de telechargement\t')
print "\n\n\n\n\n\t\tAucun fichier dans la liste"
footer()
choice='r'
time.sleep(1)
if not choice:choice=getch()
class prefs:
def __init__(self):
from API import API
from APIPrive import APIPrive
from PluginManager import PluginManager
################################################
# Instanciations + initialisation de variables #
################################################
# On instancie le plugin manager
self.pluginManager = PluginManager()
# On instancie le gestionnaire de preferences et sa fenetre
self.preferences = Preferences()
# On instancie le gestionnaire de download
self.downloader = Downloader()
# On instancie seulement les plugins qui sont selectionnes dans les preferences
#~ self.pluginManager.activerPlugins( self.preferences.getPreference( "pluginsActifs" ) )
# On recupere l'instance de API
self.api = API.getInstance()
# On met en place la liste des plugins dans API
current=0
global choice
choice=''
while choice!='r' and choice!='R':
# self.api.setListeInstance( getattr( self.pluginManager, "listeInstances" ) )
pluginsActifs = self.pluginManager.listeInstances
plugins = self.pluginManager.getListeSites()
plugins.sort()
rep= self.preferences.getPreference( "repertoireTelechargement" )
# if choice.isdigit() and int(choice) < int(len(plugins)-10*current): print int(choice)+int(10*current)
# elif choice.isdigit() and int(choice) > int(len(plugins)-10*current): print int(choice)+int(10*current)
if choice=='q' or choice=='Q':
quitter()
elif choice.isdigit() and int(choice) < int(len(plugins)-10*current):
if plugins[int(choice)+10*current] in pluginsActifs:
self.pluginManager.desactiverPlugin(plugins[int(choice)+10*current])
print int(choice)+10*current,
else:
self.pluginManager.activerPlugin(plugins[int(choice)+10*current])
print int(choice)+10*current,
elif choice=='m' or choice =='M':
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Repertoire de telechargement')
choice=raw_input('\n\n\n\n\n\n\n\tVeuillez saisir un repertoire valide\n\n\t\t')
if not os.path.isdir(choice):
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Repertoire de telechargement')
print "\n\n\n\n\n\n\n\trepertoire ",choice," inexistant\n\n\t\tRepertoire courant:",rep
else :
os.system(['clear','cls'][os.name == 'nt'])
header ('','','Repertoire de telechargement')
rep=choice
print "\n\n\n\n\n\n\n\tModification du repertoire de telechargement :\n\n\t\tNouveau repertoire :",choice
self.preferences.setPreference( "repertoireTelechargement", str(rep))
time.sleep(1)
elif choice=='+':
if len(plugins)>current*15+15: current+=1
elif choice=='-':
if current!=0: current-=1
#affichage a l'ecran de la liste
header ('','','Menus des options')
print " Repertoire de telechargement :",rep
for i in range(10) :
if i+10*current<len(plugins):
print "\n ",i,":",plugins[i+10*current],
if len(plugins[i+10*current])<=8:print"\t\t",
elif len(plugins[i+10*current])<=15:print"\t",
for j in pluginsActifs:
if j==plugins[i+10*current]:
print "actif",
else: print ""
print "\n\n m:modifier le repertoire de telechargement +/-:afficher les autres plugins"
footer()
choice=getch()
liste=[]
for instance in pluginsActifs:
liste.append(instance)
self.preferences.setPreference( "pluginsActifs", liste)
self.preferences.sauvegarderConfiguration()
def info():
choice=''
while choice!='r' and choice!='R':
header ('','','Credits & license')
print "\t\t\tGNU GENERAL PUBLIC LICENSE"
print "\t\t\tVersion 2, June 1991"
print ""
print ""
print ""
print "\t\t\tDéveloppeurs :"
print "\t\t\t\t- chaoswizard"
print "\t\t\t\t- ggauthier.ggl"
print "\t\t\t\t"
print "\t\t\tDéveloppeur CLI :"
print "\t\t\t\ttvelter"
print ""
print "\t\t\tPlugins :"
print "\t\t\t\tBmD_Online"
print ""
print ""
footer()
if choice=='q' or choice=='Q':
quitter()
choice=getch()
def quitter():
#quitter program apres confirmation utilisateur
choice = ""
if not choice :
os.system(['clear','cls'][os.name == 'nt'])
sys.exit()
header ('','Quitter ?','')
print "\n\n\n\n\n\t\tAre you sure you want to quit ? (y/n)"
choice=getch()
if choice=='y' or choice=='Y':
os.system(['clear','cls'][os.name == 'nt'])
sys.exit()
elif choice!='y' and choice!='Y':
os.system(['clear','cls'][os.name == 'nt'])
header ('','Quitter ?','')
print "\n\n\n\n\n\t\tRetour a l'interface du programme"
print "#"
time.sleep(1)
print "#"
os.system(['clear','cls'][os.name == 'nt'])
# @param time: duree d'affichage du message d'attente
def wait(duree):
#Affichage d'un message d'attente pendant le chargement des infos ou le telechargmeent des fichiers
# Fenetre d'attente
os.system(['clear','cls'][os.name == 'nt'])
print "Patientez pendant l'actualisation des informations"
#while get info not finished
for i in range(duree):
time.sleep(1)
print "#",
#os.system(['clear','cls'][os.name == 'nt'])
| Python |
class getch:
"""Gets a single character from standard input. Does not echo to the screen."""
def __init__(self):
try:
self.impl = _GetchWindows()
except ImportError:
self.impl = _GetchUnix()
def __call__(self): return self.impl()
class _GetchUnix:
def __init__(self):
import tty, sys
def __call__(self):
import sys, tty, termios
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
class _GetchWindows:
def __init__(self):
import msvcrt
def __call__(self):
import msvcrt
return msvcrt.getch()
getch = getch()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import re
########
# Code #
########
# RegEx de decoupage d'un lien RTMP
RTMP_URL_PATTERN = re.compile("(?P<scheme>[^:]*)://(?P<host>[^/^:]*):{0,1}(?P<port>[^/]*)/(?P<app>.*?)/(?P<playpath>\w*?\:.*)", re.DOTALL)
## Fonction qui transforme un lien RTMP en commande rtmpdump
# @param url URL RTMP a transformer
# @return Commande rtmpdump obtenue
def urlToRtmpdump( url ):
match = re.match( RTMP_URL_PATTERN, url )
comand = ""
if match != None:
comand = "rtmpdump --host %host% --port %port% --protocol %scheme% --app %app% --playpath %playpath%"
comand = comand.replace( "%scheme%", match.group( "scheme" ) ).replace( "%host%", match.group( "host" ) ).replace( "%app%", match.group( "app" ) ).replace( "%playpath%", match.group( "playpath" ) )
if( match.group( "port" ) != "" ):
comand = comand.replace( "%port%", match.group( "port" ) )
elif( url[ :6 ] == "rtmpte" ):
comand = comand.replace( "%port%", "80" )
elif( url[ :5 ] == "rtmpe" ):
comand = comand.replace( "%port%", "1935" )
elif( url[ :5 ] == "rtmps" ):
comand = comand.replace( "%port%", "443" )
elif( url[ :5 ] == "rtmpt" ):
comand = comand.replace( "%port%", "80" )
else:
comand = comand.replace( "%port%", "1935" )
else:
comand = "rtmpdump -r " + url
return comand
| Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'TvDownloaderPluzzWidget.ui'
#
# Created: Thu Jan 13 22:07:19 2011
# by: PyQt4 UI code generator 4.7.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_TvDownloaderPluzzWidget(object):
def setupUi(self, TvDownloaderPluzzWidget):
TvDownloaderPluzzWidget.setObjectName("TvDownloaderPluzzWidget")
TvDownloaderPluzzWidget.resize(760, 540)
self.gridLayoutWidget = QtGui.QWidget(TvDownloaderPluzzWidget)
self.gridLayoutWidget.setGeometry(QtCore.QRect(10, 10, 741, 521))
self.gridLayoutWidget.setObjectName("gridLayoutWidget")
self.gridLayout_TV = QtGui.QGridLayout(self.gridLayoutWidget)
self.gridLayout_TV.setObjectName("gridLayout_TV")
self.pushButton_France2 = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_France2.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_France2.setMouseTracking(False)
self.pushButton_France2.setFocusPolicy(QtCore.Qt.TabFocus)
self.pushButton_France2.setAutoFillBackground(False)
self.pushButton_France2.setText("France 2")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("img/02_France2_256x256.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_France2.setIcon(icon)
self.pushButton_France2.setIconSize(QtCore.QSize(128, 128))
self.pushButton_France2.setObjectName("pushButton_France2")
self.gridLayout_TV.addWidget(self.pushButton_France2, 0, 0, 1, 1)
self.pushButton_France3 = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_France3.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_France3.setMouseTracking(False)
self.pushButton_France3.setFocusPolicy(QtCore.Qt.TabFocus)
self.pushButton_France3.setAutoFillBackground(False)
self.pushButton_France3.setText("France 3")
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap("img/03_France3_256x256.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_France3.setIcon(icon1)
self.pushButton_France3.setIconSize(QtCore.QSize(128, 128))
self.pushButton_France3.setObjectName("pushButton_France3")
self.gridLayout_TV.addWidget(self.pushButton_France3, 0, 1, 1, 1)
self.pushButton_France5 = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_France5.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_France5.setMouseTracking(False)
self.pushButton_France5.setFocusPolicy(QtCore.Qt.NoFocus)
self.pushButton_France5.setAutoFillBackground(False)
self.pushButton_France5.setText("France 5")
icon2 = QtGui.QIcon()
icon2.addPixmap(QtGui.QPixmap("img/05_France5_256x256.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_France5.setIcon(icon2)
self.pushButton_France5.setIconSize(QtCore.QSize(128, 128))
self.pushButton_France5.setObjectName("pushButton_France5")
self.gridLayout_TV.addWidget(self.pushButton_France5, 1, 0, 1, 1)
self.pushButton_FranceO = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_FranceO.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_FranceO.setMouseTracking(False)
self.pushButton_FranceO.setFocusPolicy(QtCore.Qt.NoFocus)
self.pushButton_FranceO.setAutoFillBackground(False)
self.pushButton_FranceO.setText("France O")
icon3 = QtGui.QIcon()
icon3.addPixmap(QtGui.QPixmap("img/19_FranceO_256x256.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_FranceO.setIcon(icon3)
self.pushButton_FranceO.setIconSize(QtCore.QSize(128, 128))
self.pushButton_FranceO.setObjectName("pushButton_FranceO")
self.gridLayout_TV.addWidget(self.pushButton_FranceO, 1, 1, 1, 1)
self.pushButton_France4 = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_France4.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_France4.setMouseTracking(False)
self.pushButton_France4.setFocusPolicy(QtCore.Qt.NoFocus)
self.pushButton_France4.setAutoFillBackground(False)
self.pushButton_France4.setText("France 4")
icon4 = QtGui.QIcon()
icon4.addPixmap(QtGui.QPixmap("img/14_France4_256x256.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_France4.setIcon(icon4)
self.pushButton_France4.setIconSize(QtCore.QSize(128, 128))
self.pushButton_France4.setObjectName("pushButton_France4")
self.gridLayout_TV.addWidget(self.pushButton_France4, 0, 2, 1, 1)
self.pushButton_Back = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_Back.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_Back.setMouseTracking(False)
self.pushButton_Back.setFocusPolicy(QtCore.Qt.NoFocus)
self.pushButton_Back.setAutoFillBackground(False)
self.pushButton_Back.setText("Retour")
icon5 = QtGui.QIcon()
icon5.addPixmap(QtGui.QPixmap("ico/gtk-go-back.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_Back.setIcon(icon5)
self.pushButton_Back.setIconSize(QtCore.QSize(128, 128))
self.pushButton_Back.setObjectName("pushButton_Back")
self.gridLayout_TV.addWidget(self.pushButton_Back, 1, 2, 1, 1)
self.retranslateUi(TvDownloaderPluzzWidget)
QtCore.QObject.connect(self.pushButton_Back, QtCore.SIGNAL("clicked()"), TvDownloaderPluzzWidget.close)
QtCore.QMetaObject.connectSlotsByName(TvDownloaderPluzzWidget)
def retranslateUi(self, TvDownloaderPluzzWidget):
TvDownloaderPluzzWidget.setWindowTitle(QtGui.QApplication.translate("TvDownloaderPluzzWidget", "Form", None, QtGui.QApplication.UnicodeUTF8))
if __name__ == "__main__":
import sys
app = QtGui.QApplication(sys.argv)
TvDownloaderPluzzWidget = QtGui.QWidget()
ui = Ui_TvDownloaderPluzzWidget()
ui.setupUi(TvDownloaderPluzzWidget)
TvDownloaderPluzzWidget.show()
sys.exit(app.exec_())
| Python |
from PyQt4 import QtGui, QtCore
from TvDownloaderSitesWidgetView import Ui_TvDownloaderSitesWidget
class TvDownloaderSitesWidgetController(QtGui.QWidget):
def __init__(self, parent):
QtGui.QWidget.__init__(self)
self.mainWindow = parent
self.ui = Ui_TvDownloaderSitesWidget()
self.ui.setupUi(self)
# Connect the events
self.connect(self.ui.pushButton_Arte, QtCore.SIGNAL('clicked()'), self.arteClicked)
self.connect(self.ui.pushButton_Canal, QtCore.SIGNAL('clicked()'), self.canalClicked)
self.connect(self.ui.pushButton_M6Replay, QtCore.SIGNAL('clicked()'), self.m6Clicked)
self.connect(self.ui.pushButton_Pluzz, QtCore.SIGNAL('clicked()'), self.pluzzClicked)
self.connect(self.ui.pushButton_W9Replay, QtCore.SIGNAL('clicked()'), self.w9Clicked)
def arteClicked(self):
print 'TvDownloaderSitesWidgetController>> arteClicked'
def canalClicked(self):
print 'TvDownloaderSitesWidgetController>> canalClicked'
def m6Clicked(self):
print 'TvDownloaderSitesWidgetController>> m6Clicked'
def pluzzClicked(self):
print 'TvDownloaderSitesWidgetController>> pluzzClicked'
self.mainWindow.updateCentralWidget('site_pluzz')
def w9Clicked(self):
print 'TvDownloaderSitesWidgetController>> w9Clicked' | Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'TvDownloaderMainWindow.ui'
#
# Created: Thu Jan 13 22:07:18 2011
# by: PyQt4 UI code generator 4.7.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_TvDownloaderMainWindow(object):
def setupUi(self, TvDownloaderMainWindow):
TvDownloaderMainWindow.setObjectName("TvDownloaderMainWindow")
TvDownloaderMainWindow.resize(800, 600)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("ico/TVDownloader.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
TvDownloaderMainWindow.setWindowIcon(icon)
self.centralwidget = QtGui.QWidget(TvDownloaderMainWindow)
self.centralwidget.setObjectName("centralwidget")
self.widget = QtGui.QWidget(self.centralwidget)
self.widget.setGeometry(QtCore.QRect(20, 5, 760, 540))
self.widget.setObjectName("widget")
TvDownloaderMainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(TvDownloaderMainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 25))
self.menubar.setObjectName("menubar")
self.menuFichier = QtGui.QMenu(self.menubar)
self.menuFichier.setObjectName("menuFichier")
self.menuEdition = QtGui.QMenu(self.menubar)
self.menuEdition.setObjectName("menuEdition")
self.menuAide = QtGui.QMenu(self.menubar)
self.menuAide.setObjectName("menuAide")
TvDownloaderMainWindow.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(TvDownloaderMainWindow)
self.statusbar.setObjectName("statusbar")
TvDownloaderMainWindow.setStatusBar(self.statusbar)
self.actionQuit = QtGui.QAction(TvDownloaderMainWindow)
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap("ico/gtk-quit.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.actionQuit.setIcon(icon1)
self.actionQuit.setMenuRole(QtGui.QAction.QuitRole)
self.actionQuit.setIconVisibleInMenu(True)
self.actionQuit.setObjectName("actionQuit")
self.actionAbout = QtGui.QAction(TvDownloaderMainWindow)
icon2 = QtGui.QIcon()
icon2.addPixmap(QtGui.QPixmap("ico/gtk-about.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.actionAbout.setIcon(icon2)
self.actionAbout.setIconVisibleInMenu(True)
self.actionAbout.setObjectName("actionAbout")
self.actionUpdatePlugins = QtGui.QAction(TvDownloaderMainWindow)
icon3 = QtGui.QIcon()
icon3.addPixmap(QtGui.QPixmap("ico/gtk-refresh.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.actionUpdatePlugins.setIcon(icon3)
self.actionUpdatePlugins.setIconVisibleInMenu(True)
self.actionUpdatePlugins.setObjectName("actionUpdatePlugins")
self.actionPreferences = QtGui.QAction(TvDownloaderMainWindow)
icon4 = QtGui.QIcon()
icon4.addPixmap(QtGui.QPixmap("ico/gtk-preferences.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.actionPreferences.setIcon(icon4)
self.actionPreferences.setIconVisibleInMenu(True)
self.actionPreferences.setObjectName("actionPreferences")
self.menuFichier.addAction(self.actionQuit)
self.menuEdition.addAction(self.actionUpdatePlugins)
self.menuEdition.addAction(self.actionPreferences)
self.menuAide.addAction(self.actionAbout)
self.menubar.addAction(self.menuFichier.menuAction())
self.menubar.addAction(self.menuEdition.menuAction())
self.menubar.addAction(self.menuAide.menuAction())
self.retranslateUi(TvDownloaderMainWindow)
QtCore.QMetaObject.connectSlotsByName(TvDownloaderMainWindow)
def retranslateUi(self, TvDownloaderMainWindow):
TvDownloaderMainWindow.setWindowTitle(QtGui.QApplication.translate("TvDownloaderMainWindow", "TvDownloader", None, QtGui.QApplication.UnicodeUTF8))
self.menuFichier.setTitle(QtGui.QApplication.translate("TvDownloaderMainWindow", "Fichier", None, QtGui.QApplication.UnicodeUTF8))
self.menuEdition.setTitle(QtGui.QApplication.translate("TvDownloaderMainWindow", "Edition", None, QtGui.QApplication.UnicodeUTF8))
self.menuAide.setTitle(QtGui.QApplication.translate("TvDownloaderMainWindow", "Aide", None, QtGui.QApplication.UnicodeUTF8))
self.actionQuit.setText(QtGui.QApplication.translate("TvDownloaderMainWindow", "Quitter", None, QtGui.QApplication.UnicodeUTF8))
self.actionQuit.setShortcut(QtGui.QApplication.translate("TvDownloaderMainWindow", "Ctrl+Q", None, QtGui.QApplication.UnicodeUTF8))
self.actionAbout.setText(QtGui.QApplication.translate("TvDownloaderMainWindow", "A propos", None, QtGui.QApplication.UnicodeUTF8))
self.actionUpdatePlugins.setText(QtGui.QApplication.translate("TvDownloaderMainWindow", "Mise à jour des plugins", None, QtGui.QApplication.UnicodeUTF8))
self.actionUpdatePlugins.setShortcut(QtGui.QApplication.translate("TvDownloaderMainWindow", "Ctrl+U", None, QtGui.QApplication.UnicodeUTF8))
self.actionPreferences.setText(QtGui.QApplication.translate("TvDownloaderMainWindow", "Préférences", None, QtGui.QApplication.UnicodeUTF8))
self.actionPreferences.setShortcut(QtGui.QApplication.translate("TvDownloaderMainWindow", "Ctrl+P", None, QtGui.QApplication.UnicodeUTF8))
if __name__ == "__main__":
import sys
app = QtGui.QApplication(sys.argv)
TvDownloaderMainWindow = QtGui.QMainWindow()
ui = Ui_TvDownloaderMainWindow()
ui.setupUi(TvDownloaderMainWindow)
TvDownloaderMainWindow.show()
sys.exit(app.exec_())
| Python |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'TvDownloaderSitesWidget.ui'
#
# Created: Thu Jan 13 22:07:19 2011
# by: PyQt4 UI code generator 4.7.4
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
class Ui_TvDownloaderSitesWidget(object):
def setupUi(self, TvDownloaderSitesWidget):
TvDownloaderSitesWidget.setObjectName("TvDownloaderSitesWidget")
TvDownloaderSitesWidget.resize(760, 540)
self.gridLayoutWidget = QtGui.QWidget(TvDownloaderSitesWidget)
self.gridLayoutWidget.setGeometry(QtCore.QRect(10, 10, 741, 521))
self.gridLayoutWidget.setObjectName("gridLayoutWidget")
self.gridLayout_TV = QtGui.QGridLayout(self.gridLayoutWidget)
self.gridLayout_TV.setObjectName("gridLayout_TV")
self.pushButton_Arte = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_Arte.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_Arte.setMouseTracking(False)
self.pushButton_Arte.setFocusPolicy(QtCore.Qt.TabFocus)
self.pushButton_Arte.setAutoFillBackground(False)
self.pushButton_Arte.setText("Arte")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("img/07_ARTE_256x256.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_Arte.setIcon(icon)
self.pushButton_Arte.setIconSize(QtCore.QSize(128, 128))
self.pushButton_Arte.setObjectName("pushButton_Arte")
self.gridLayout_TV.addWidget(self.pushButton_Arte, 0, 0, 1, 1)
self.pushButton_Canal = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_Canal.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_Canal.setMouseTracking(False)
self.pushButton_Canal.setFocusPolicy(QtCore.Qt.TabFocus)
self.pushButton_Canal.setAutoFillBackground(False)
self.pushButton_Canal.setText("Canal+")
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap("img/04_Canal+_256x256.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_Canal.setIcon(icon1)
self.pushButton_Canal.setIconSize(QtCore.QSize(128, 128))
self.pushButton_Canal.setObjectName("pushButton_Canal")
self.gridLayout_TV.addWidget(self.pushButton_Canal, 0, 1, 1, 1)
self.pushButton_Pluzz = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_Pluzz.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_Pluzz.setMouseTracking(False)
self.pushButton_Pluzz.setFocusPolicy(QtCore.Qt.NoFocus)
self.pushButton_Pluzz.setAutoFillBackground(False)
self.pushButton_Pluzz.setText("Pluzz")
icon2 = QtGui.QIcon()
icon2.addPixmap(QtGui.QPixmap("img/Pluzz_470x318.jpg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_Pluzz.setIcon(icon2)
self.pushButton_Pluzz.setIconSize(QtCore.QSize(128, 128))
self.pushButton_Pluzz.setObjectName("pushButton_Pluzz")
self.gridLayout_TV.addWidget(self.pushButton_Pluzz, 1, 0, 1, 1)
self.pushButton_W9Replay = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_W9Replay.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_W9Replay.setMouseTracking(False)
self.pushButton_W9Replay.setFocusPolicy(QtCore.Qt.NoFocus)
self.pushButton_W9Replay.setAutoFillBackground(False)
self.pushButton_W9Replay.setText("W9 Replay")
icon3 = QtGui.QIcon()
icon3.addPixmap(QtGui.QPixmap("img/W9_Replay_220x122.jpg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_W9Replay.setIcon(icon3)
self.pushButton_W9Replay.setIconSize(QtCore.QSize(128, 128))
self.pushButton_W9Replay.setObjectName("pushButton_W9Replay")
self.gridLayout_TV.addWidget(self.pushButton_W9Replay, 1, 1, 1, 1)
self.pushButton_M6Replay = QtGui.QPushButton(self.gridLayoutWidget)
self.pushButton_M6Replay.setCursor(QtCore.Qt.PointingHandCursor)
self.pushButton_M6Replay.setMouseTracking(False)
self.pushButton_M6Replay.setFocusPolicy(QtCore.Qt.NoFocus)
self.pushButton_M6Replay.setAutoFillBackground(False)
self.pushButton_M6Replay.setText("M6 Replay")
icon4 = QtGui.QIcon()
icon4.addPixmap(QtGui.QPixmap("img/M6_Replay_450x295.jpg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.pushButton_M6Replay.setIcon(icon4)
self.pushButton_M6Replay.setIconSize(QtCore.QSize(128, 128))
self.pushButton_M6Replay.setObjectName("pushButton_M6Replay")
self.gridLayout_TV.addWidget(self.pushButton_M6Replay, 0, 2, 1, 1)
self.retranslateUi(TvDownloaderSitesWidget)
QtCore.QMetaObject.connectSlotsByName(TvDownloaderSitesWidget)
def retranslateUi(self, TvDownloaderSitesWidget):
TvDownloaderSitesWidget.setWindowTitle(QtGui.QApplication.translate("TvDownloaderSitesWidget", "Form", None, QtGui.QApplication.UnicodeUTF8))
if __name__ == "__main__":
import sys
app = QtGui.QApplication(sys.argv)
TvDownloaderSitesWidget = QtGui.QWidget()
ui = Ui_TvDownloaderSitesWidget()
ui.setupUi(TvDownloaderSitesWidget)
TvDownloaderSitesWidget.show()
sys.exit(app.exec_())
| Python |
from PyQt4 import QtGui, QtCore
from TvDownloaderPluzzWidgetView import Ui_TvDownloaderPluzzWidget
class TvDownloaderPluzzWidgetController(QtGui.QWidget):
def __init__(self, parent):
QtGui.QWidget.__init__(self)
self.mainWindow = parent
self.ui = Ui_TvDownloaderPluzzWidget()
self.ui.setupUi(self)
# Connect the events
self.connect(self.ui.pushButton_France2, QtCore.SIGNAL('clicked()'), self.france2Clicked)
self.connect(self.ui.pushButton_France3, QtCore.SIGNAL('clicked()'), self.france3Clicked)
self.connect(self.ui.pushButton_France4, QtCore.SIGNAL('clicked()'), self.france4Clicked)
self.connect(self.ui.pushButton_France5, QtCore.SIGNAL('clicked()'), self.france5Clicked)
self.connect(self.ui.pushButton_FranceO, QtCore.SIGNAL('clicked()'), self.franceOClicked)
self.connect(self.ui.pushButton_Back, QtCore.SIGNAL('clicked()'), self.backClicked)
def france2Clicked(self):
print 'TvDownloaderPluzzWidgetController>> france2 clicked'
def france3Clicked(self):
print 'TvDownloaderPluzzWidgetController>> france3 clicked'
def france4Clicked(self):
print 'TvDownloaderPluzzWidgetController>> france4 clicked'
def france5Clicked(self):
print 'TvDownloaderPluzzWidgetController>> france5 clicked'
def franceOClicked(self):
print 'TvDownloaderPluzzWidgetController>> franceO clicked'
def backClicked(self):
print 'TvDownloaderPluzzWidgetController>> franceO clicked'
self.mainWindow.updateCentralWidget('back') | Python |
from PyQt4 import QtGui, QtCore
from GUI.AProposDialog import AProposDialog
from GUI.PreferencesDialog import PreferencesDialog
from GUI.UpdateManagerDialog import UpdateManagerDialog
from TvDownloaderMainWindowView import Ui_TvDownloaderMainWindow
from TvDownloaderSitesWidgetController import TvDownloaderSitesWidgetController
from TvDownloaderPluzzWidgetController import TvDownloaderPluzzWidgetController
class TvDownloaderMainWindowController(QtGui.QMainWindow):
def __init__(self):
QtGui.QMainWindow.__init__(self)
# Load the View
self.ui = Ui_TvDownloaderMainWindow()
self.ui.setupUi(self)
# Connect the HMI Events
self.connect(self.ui.actionQuit, QtCore.SIGNAL('triggered()'), self.close)
self.connect(self.ui.actionUpdatePlugins, QtCore.SIGNAL('triggered()'), self.openUpdatePluginsWindow)
self.connect(self.ui.actionPreferences, QtCore.SIGNAL('triggered()'), self.openPreferencesWindow)
self.connect(self.ui.actionAbout, QtCore.SIGNAL('triggered()'), self.openAboutDialog)
# Define the other dialogs
self.updatePluginsDlg = None
self.preferencesDlg = None
self.aboutDlg = None
# Init the main widget
self.previousWidgetID = 'main_menu'
self.updateCentralWidget(self.previousWidgetID)
def updateCentralWidget(self, strWidgetID):
if strWidgetID == 'main_menu':
self.setCentralWidget(TvDownloaderSitesWidgetController(self))
elif strWidgetID == "site_arte":
print 'TvDownloaderMainWindowController>> display site Arte'
elif strWidgetID == "site_canal":
print 'TvDownloaderMainWindowController>> display site Canal+'
elif strWidgetID == "site_m6replay":
print 'TvDownloaderMainWindowController>> display site M6Replay'
elif strWidgetID == "site_pluzz":
print 'TvDownloaderMainWindowController>> display site Pluzz'
self.setCentralWidget(TvDownloaderPluzzWidgetController(self))
elif strWidgetID == "site_w9replay":
print 'TvDownloaderMainWindowController>> display site W9'
elif strWidgetID == 'back':
print 'TvDownloaderMainWindowController>> back'
self.updateCentralWidget(self.previousWidgetID)
def openUpdatePluginsWindow(self):
if self.updatePluginsDlg == None:
self.updatePluginsDlg = UpdateManagerDialog(self)
self.updatePluginsDlg.afficher()
def openPreferencesWindow(self):
if self.preferencesDlg == None:
self.preferencesDlg = PreferencesDialog(self)
self.preferencesDlg.afficher()
def openAboutDialog(self):
if self.aboutDlg == None:
self.aboutDlg = AProposDialog()
self.aboutDlg.show()
if __name__ == "__main__":
import sys
app = QtGui.QApplication(sys.argv)
win = TvDownloaderMainWindowController()
win.show()
sys.exit(app.exec_()) | Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import logging
import optparse
import os
import sys
import Constantes
#
# Entree du programme
#
if __name__ == "__main__" :
# On se deplace dans le repertoire de travail (pas necessaire sous Windows)
if( not Constantes.OS_WINDOWS ):
# On se deplace dans le repertoire de travail du logciel
repertoireTravail = os.path.dirname( os.path.abspath( __file__ ) )
sys.path.insert( 0, repertoireTravail )
os.chdir( repertoireTravail )
# Options a parser
parser = optparse.OptionParser()
parser.add_option( "-v", "--verbose",
action = "store_true", dest = "verbose", default = False,
help = "Affiche informations dans le terminal" )
parser.add_option( "-c", "--cli",
action = "store_true", dest = "cli", default = False,
help = "Affiche la version CLI" )
parser.add_option( "-d", "--dialog",
action = "store_true", dest = "dialog", default = False,
help = u"Affiche la version Dialog (en cours de développement)" )
parser.add_option( "-g", "--genererXML",
action = "store_true", dest = "genererXML", default = False,
help = u"Génère le fichier XML qui decrit les plugins" )
options, args = parser.parse_args()
# On a active le mode verbeux ?
logger = logging.getLogger( __name__ )
console = logging.StreamHandler( sys.stdout )
if( options.verbose ):
logger.setLevel( logging.DEBUG )
console.setLevel( logging.DEBUG )
else:
logger.setLevel( logging.ERROR )
console.setLevel( logging.ERROR )
console.setFormatter( logging.Formatter( '%(levelname)-7s %(name)s : %(message)s' ) )
logger.addHandler( console )
# On veut generer le fichier XML qui decrit les plugins
if( options.genererXML ):
import UpdateManager
UpdateManager.UpdateManager.creerXML()
sys.exit( 0 )
# On met en place les repertoires de travail du logiciel
repertoires = [ Constantes.REPERTOIRE_CACHE, \
Constantes.REPERTOIRE_CONFIGURATION, \
Constantes.REPERTOIRE_LOGS, \
Constantes.REPERTOIRE_PLUGIN_PERSO ]
for repertoire in repertoires:
if( not os.path.isdir( repertoire ) ):
logger.info( "création du répertoire %s" %( repertoire ) )
os.makedirs( repertoire )
# On demarre le CLI ou le GUI ?
if( options.cli == False and options.dialog == False ):
# On importe les fichiers necessaires pour le GUI
try:
from PyQt4 import QtGui, QtCore
except ImportError:
logger.critical( "ouuupppss : il vous faut PyQt4 pour pouvoir utiliser ce programme..." )
sys.exit( 1 )
# from GUI.MainWindow import MainWindow
from GUINextGen.PyQt.TvDownloaderMainWindowController import TvDownloaderMainWindowController
# On creer l'interface graphique
# app = QtGui.QApplication( sys.argv )
# window = MainWindow()
# window.show()
# sys.exit( app.exec_() )
app = QtGui.QApplication(sys.argv)
MainWindow = TvDownloaderMainWindowController()
MainWindow.show()
sys.exit(app.exec_())
elif( options.cli == True ):
from CLI.cli import cli
cli()
else:
from CLIDialog.CLIDialog import CLIDialog
CLIDialog()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier LICENSE #
#########################################
#~ Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
#~ Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
#~ Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import httplib,re
from random import choice
from APIPrive import APIPrive
from urlparse import urlparse
from traceback import print_exc
from Navigateur import Navigateur
##########
# Classe #
##########
## Classe rassemblant des méthodes utils et nécessaire aux plugins.
#
# Cette classe fournis des méthodes permattant de facilité la création d'un plugin. Elle est pour l'instant peu fournis mais a pour but d'être étoffé avec le temps et la possible augmentation de fonctionnalité possible des plugins.
# Elle contient aussi des méthodes permettant de dialoguer avec le programme.
class API(APIPrive):
## Instance utilisé par le programme
INSTANCE = None
## Constructeur.
# Ne pas utiliser.
# @param self l'objet courant
def __init__( self ):
self.navigateur = Navigateur()
APIPrive.__init__( self )
if API.INSTANCE != None:
raise Exception("API est déjà instancier")
## Renvoie l'instance d'API
# @return l'instance d'API
@staticmethod
def getInstance():
"""Renvoie l'instance de l'API"""
return API.INSTANCE
## Récupère une page web sur internet et remplace les caractères spéciaux (code HTML ou ISO).
# @param self le plugin courant
# @param url l'url de la page web
# @return la page web sous forme d'une chaîne ou la chaîne vide en cas d'échec
def getPage(self, url):
return self.navigateur.getPage( url )
#~
#~ #Vérification de l'url
#~ match = re.match(API.PATTERN_URL, url)
#~ if match == None:
#~ print "API.getPage(): url invalide."
#~ return ""
#~
#~ #Téléchargement et décompression si néscessaire
#~ try:
#~ connexion = httplib.HTTPConnection(match.group(1), timeout=APIPrive.HTTP_TIMEOUT)
#~
#~ heads = {"Accept-Encoding":"deflate,gzip",
#~ "Accept-Charset":"iso-8859-5, utf-8",
#~ "User-Agent":choice(APIPrive.USER_AGENT)}
#~ connexion.request("GET", match.group(2), headers=heads)
#~ reponse = connexion.getresponse()
#~ if reponse == None:
#~ print "API.getPage(): erreur de téléchargement."
#~ return ""
#~ return self.reponseHttpToUTF8(reponse)
#~ except Exception, ex:
#~ print "API.getPage(): erreur de téléchargement.",ex
#~ print_exc()
#~ return ""
def getPicture( self, url ):
return self.navigateur.getPicture( url )
## Récupère des pages webs sur internet et remplace les caractères spéciaux (code HTML ou ISO). Cette méthode reste connecté au serveur si il y a plusieurs page à y télécharger, elle est plus rapide que plusieurs appel à #getPage.
# @param self le plugin courant
# @param urls une liste d'url des pages à télécharger
# @return un dictionnaire avec comme clé les urls et comme valeur les pages sous forme de chaîne
def getPages(self, urls):
reponses = self.navigateur.getPages( urls )
return reponses
#~ reponses = {}
#~ for url in urls:
#~ reponses[ url ] = self.navigateur.getPage( url )
#~ reponses = {}
#~ connexions = {}
#~ user = choice(APIPrive.USER_AGENT)
#~ for url in urls:
#~ parse = urlparse(url)
#~ query = parse.query
#~ if query != "":
#~ query = "?"+query
#~ path = parse.path
#~ if path == "":
#~ path = "/"
#~
#~ requette = path+query
#~ serveur= parse.netloc
#~
#~ try:
#~ connexion = None
#~ if not connexions.has_key(serveur):
#~ connexion = httplib.HTTPConnection(serveur, timeout=APIPrive.HTTP_TIMEOUT)
#~ connexion.connect()
#~ connexions[serveur] = connexion
#~ else:
#~ connexion = connexions[serveur]
#~ connexion.putrequest("GET", requette)
#~ connexion.putheader("Connexion", "Keep-alive")
#~ connexion.putheader("Accept-Encoding", "deflate,gzip")
#~ connexion.putheader("Accept-Charset", "iso-8859-5, utf-8")
#~ connexion.putheader("User-Agent", user)
#~ connexion.endheaders()
#~
#~ reponse = connexion.getresponse()
#~ if reponse == None:
#~ print "API.getPages(): erreur de téléchargement de",url
#~ reponses[url] = ""
#~ else:
#~ reponses[url] = self.reponseHttpToUTF8(reponse)
#~ except Exception, ex:
#~ print "API.getPages(): erreur de téléchargement.",ex
#~ print_exc()
#~ for serveur in connexions.keys():
#~ connexions[serveur].close()
#~ return reponses
API.INSTANCE = API()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier LICENSE #
#########################################
#~ Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
#~ Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
#~ Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import re
import os
import os.path
import pickle
import urllib
from Fichier import Fichier
from Plugin import Plugin
##########
# Classe #
##########
class RTL( Plugin ):
listeEmissionsRegEx = re.compile( "<h4>(.+?)</h4>.*?podcast.rtl.fr/(.+?).xml", re.DOTALL )
def __init__( self):
Plugin.__init__( self, "RTL", "http://www.rtl.fr", 7 )
self.listeChaines = {} # Clef = nom chaine ; Valeur = { nom emission : lien fichier XML qui contient la liste des emissions }
self.derniereChaine = ""
if os.path.exists( self.fichierCache ):
self.listeChaines = self.chargerCache()
def rafraichir( self ):
self.afficher( u"Récupération de la liste des chaines et des émissions..." )
# On remet a zero la liste des chaines
self.listeChaines.clear()
# On recupere la page qui contient les emissions
page = self.API.getPage( "http://www.rtl.fr/podcast.html" )
# On decoupe la page selon le nom des chaines
resultats = re.split( "<h3>([^<]+)</h3>", page )[ 1 : ]
for ( chaine, texteChaine ) in ( zip( resultats[ 0::2 ], resultats[ 1::2 ] ) ):
# On ajoute la chaine
self.listeChaines[ chaine ] = {}
# On extrait le nom des emissions et les liens des fichiers XML correspondants
resultatsEmissions = re.findall( self.listeEmissionsRegEx, texteChaine )
for res in resultatsEmissions:
nom = res[ 0 ]
lien = "http://podcast.rtl.fr/" + res[ 1 ] + ".xml"
self.listeChaines[ chaine ][ nom ] = lien
self.sauvegarderCache( self.listeChaines )
self.afficher( str( len( self.listeChaines ) ) + " chaines concervées." )
def listerChaines( self ):
print self.listeChaines
for chaine in self.listeChaines.keys():
self.ajouterChaine( chaine )
def listerEmissions( self, chaine ):
if( self.listeChaines.has_key( chaine ) ):
self.derniereChaine = chaine
for emission in self.listeChaines[ chaine ].keys():
self.ajouterEmission( chaine, emission )
def listerFichiers( self, emission ):
if( self.listeChaines.has_key( self.derniereChaine ) ):
if( self.listeChaines[ self.derniereChaine ].has_key( emission ) ):
# On recupere le lien de la page de l'emission
lienPage = self.listeChaines[ self.derniereChaine ][ emission ]
# On recupere la page de l'emission
page = self.API.getPage( lienPage )
# On recupere le lien de l'image de l'emission
try :
urlImage = re.findall( '<image><url>([^<]+?)</url>', page )[ 0 ]
except :
urlImage = ""
# On extrait les emissions
resultats = re.findall( "media_url=([^\"]*)\"", page )
for res in resultats:
lien = urllib.unquote( res )
listeDates = re.findall( "(\d{4})/(\d{4})", lien )
if( listeDates == [] ): # Si on n'a pas pu extraire une date
date = "Inconnue"
else: # Si on a extrait une date
date = listeDates[ 0 ][ 1 ][ 2:4 ] + "-" + listeDates[ 0 ][ 1 ][ 0:2 ] + "-" + listeDates[ 0 ][ 0 ]
self.ajouterFichier( emission, Fichier( emission + " (" + date + ")", date, lien, urlImage = urlImage ) )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier LICENSE #
#########################################
#~ Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
#~ Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
#~ Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import re
import os
import os.path
import xml.sax
from Podcasts import PodcastsHandler
from Fichier import Fichier
from Plugin import Plugin
##########
# Classe #
##########
class Europe1( Plugin ):
listeEmissionsRegEx = re.compile( "<td class=\"programme\">.+?<a href=\".+?>(.+?)</a>.+?podcasts/(.+?)\.xml", re.DOTALL )
listeFichiersRegEx = re.compile( 'media_url=([^"]*)".+?<!\[CDATA\[(.+?)\]\]>', re.DOTALL )
def __init__( self):
Plugin.__init__( self, "Europe1", "http://www.europe1.fr", 1 )
# On instancie la classe qui permet de charger les pages web
self.listeEmissions = {} # Clef = nom emission ; Valeur = lien fichier XML qui contient la liste des emissions
if os.path.exists( self.fichierCache ):
self.listeEmissions = self.chargerCache()
def rafraichir( self ):
self.afficher( u"Récupération de la liste des émissions..." )
# On remet a zero la liste des emissions
self.listeEmissions.clear()
# On recupere la page qui contient les emissions
for page in [ "http://www.europe1.fr/Radio/Podcasts/Semaine/", "http://www.europe1.fr/Radio/Podcasts/Samedi/", "http://www.europe1.fr/Radio/Podcasts/Dimanche/" ]:
pageEmissions = self.API.getPage( page )
# On extrait le nom des emissions et les liens des fichiers XML correspondants
resultats = re.findall( self.listeEmissionsRegEx, pageEmissions )
for res in resultats:
nom = res[ 0 ]
lien = "http://www.europe1.fr/podcasts/" + res[ 1 ] + ".xml"
self.listeEmissions[ nom ] = lien
self.sauvegarderCache( self.listeEmissions )
self.afficher( str( len( self.listeEmissions ) ) + " émissions concervées." )
def listerChaines( self ):
self.ajouterChaine(self.nom)
def listerEmissions( self, chaine ):
# On renvoit le resulat
liste = self.listeEmissions.keys()
liste.sort()
for emission in liste:
self.ajouterEmission(chaine, emission)
def listerFichiers( self, emission ):
if( emission != "" ):
if( emission in self.listeEmissions ):
# On recupere le lien de la page de l'emission
lienPage = self.listeEmissions[ emission ]
# On recupere la page de l'emission
page = self.API.getPage( lienPage )
# On extrait les fichiers
listeFichiers = []
handler = PodcastsHandler( listeFichiers )
try:
xml.sax.parseString( page, handler )
except:
return
# On ajoute les fichiers
for fichier in listeFichiers:
self.ajouterFichier( emission, fichier )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
# Coucou les amis
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import re
import os
import xml.sax
from xml.sax.handler import ContentHandler
import urllib
import unicodedata
from Fichier import Fichier
from Plugin import Plugin
##########
# Classe #
##########
class Podcasts( Plugin ):
listePodcasts = { "Allo Cine" : { "Bandes Annonces" : "http://rss.allocine.fr/bandesannonces/ipod" },
"Casse Croute" : { "Recettes" : "http://www.casse-croute.fr/media/cassecroute.xml" },
"Game One" : { u"E-NEWS JEUX VIDEO" : "http://podcast13.streamakaci.com/xml/GAMEONE2.xml",
u"NEWS DU JT" : "http://podcast13.streamakaci.com/xml/GAMEONE6.xml",
u"LE TEST" : "http://podcast13.streamakaci.com/xml/GAMEONE3.xml",
u"PLAY HIT" : "http://podcast13.streamakaci.com/xml/GAMEONE9.xml",
u"RETRO GAME ONE" : "http://podcast13.streamakaci.com/xml/GAMEONE11.xml",
u"Funky Web" : "http://podcast13.streamakaci.com/xml/GAMEONE26.xml"
},
"No Watch" : { u"CINEFUZZ" : "http://feeds.feedburner.com/CineFuzz?format=xml",
u"GEEK Inc (SD)" : "http://feeds.feedburner.com/GeekInc?format=xml",
u"GEEk Inc (HD)" : "http://feeds.feedburner.com/GeekIncHD?format=xml",
u"S.C.U.D.S tv (SD)" : "http://feeds2.feedburner.com/scudstv?format=xml",
u"S.C.U.D.S tv (HD)" : "http://feeds2.feedburner.com/scudshd?format=xml",
u"Tonight On Mars (SD)" : "http://feeds2.feedburner.com/tonightonmars?format=xml",
u"Zapcast tv (SD)" : "http://feeds.feedburner.com/Zapcasttv?format=xml",
u"Zapcast tv (HD)" : "http://feeds.feedburner.com/Zapcasthd?format=xml"},
"i>TELE" : { "Le Journal" : "http://podcast12.streamakaci.com/iTELE/iTELElejournal.xml" },
"RMC" : { u"Bourdin & CO" : "http://podcast.rmc.fr/channel30/RMCInfochannel30.xml",
u"Coach Courbis" : "http://podcast.rmc.fr/channel33/RMCInfochannel33.xml",
u"De quoi je me mail" : "http://podcast.rmc.fr/channel35/RMCInfochannel35.xml",
u"Intégrale Foot Made in Di Meco" : "http://podcast.rmc.fr/channel192/RMCInfochannel192.xml",
u"JO Live du jour" : "http://podcast.rmc.fr/channel196/RMCInfochannel196.xml",
u"L'Afterfoot" : "http://podcast.rmc.fr/channel59/RMCInfochannel59.xml",
u"Lahaie, l'amour et vous" : "http://podcast.rmc.fr/channel51/RMCInfochannel51.xml",
u"La politique " : "http://podcast.rmc.fr/channel179/RMCInfochannel179.xml",
u"La quotidienne courses hippiques" : "http://podcast.rmc.fr/channel197/RMCInfochannel197.xml",
u"Larqué Foot" : "http://podcast.rmc.fr/channel53/RMCInfochannel53.xml",
u"Le Billet de Guimard" : "http://podcast.rmc.fr/channel210/RMCInfochannel210.xml",
u"L'économie" : "http://podcast.rmc.fr/channel178/RMCInfochannel178.xml",
u"Le Débat du jour" : "http://podcast.rmc.fr/channel211/RMCInfochannel211.xml",
u"Le Journal du jour" : "http://podcast.rmc.fr/channel39/RMCInfochannel39.xml",
u"Le Mercato Show" : "http://podcast.rmc.fr/channel213/RMCInfochannel213.xml",
u"Le Monde Hi-Tech" : "http://podcast.rmc.fr/channel31/RMCInfochannel31.xml",
u"Les courses RMC" : "http://podcast.rmc.fr/channel193/RMCInfochannel193.xml",
u"Les Experts F1" : "http://podcast.rmc.fr/channel191/RMCInfochannel191.xml",
u"Les GG et vous" : "http://podcast.rmc.fr/channel181/RMCInfochannel181.xml",
u"Les Grandes Gueules" : "http://podcast.rmc.fr/channel36/RMCInfochannel36.xml",
u"Les Paris RMC du samedi" : "http://podcast.rmc.fr/channel160/RMCInfochannel160.xml",
u"Le Top de l'After Foot" : "http://podcast.rmc.fr/channel174/RMCInfochannel174.xml",
u"Le top de Sportisimon" : "http://podcast.rmc.fr/channel188/RMCInfochannel188.xml",
u"Le Top rugby " : "http://podcast.rmc.fr/channel176/RMCInfochannel176.xml",
u"Le Tour du jour" : "http://podcast.rmc.fr/channel209/RMCInfochannel209.xml",
u"L'invité de Bourdin & Co" : "http://podcast.rmc.fr/channel38/RMCInfochannel38.xml",
u"L'invité de Captain Larqué" : "http://podcast.rmc.fr/channel175/RMCInfochannel175.xml",
u"L'invité de Luis" : "http://podcast.rmc.fr/channel170/RMCInfochannel170.xml",
u"Love conseil " : "http://podcast.rmc.fr/channel183/RMCInfochannel183.xml",
u"Luis Attaque" : "http://podcast.rmc.fr/channel40/RMCInfochannel40.xml",
u"Moscato Show" : "http://podcast.rmc.fr/channel131/RMCInfochannel131.xml",
u"Moscato Show " : "http://podcast.rmc.fr/channel190/RMCInfochannel190.xml",
u"Motors" : "http://podcast.rmc.fr/channel42/RMCInfochannel42.xml",
u"RMC première Le 5/7" : "http://podcast.rmc.fr/channel32/RMCInfochannel32.xml",
u"RMC Sport matin" : "http://podcast.rmc.fr/channel77/RMCInfochannel77.xml",
u"Sportisimon" : "http://podcast.rmc.fr/channel186/RMCInfochannel186.xml",
u"Vos Animaux" : "http://podcast.rmc.fr/channel48/RMCInfochannel48.xml",
u"Votre Auto" : "http://podcast.rmc.fr/channel50/RMCInfochannel50.xml",
u"Votre Jardin" : "http://podcast.rmc.fr/channel52/RMCInfochannel52.xml",
u"Votre Maison" : "http://podcast.rmc.fr/channel54/RMCInfochannel54.xml"
}
}
derniereChaine = ""
listeFichiers = []
def __init__( self):
Plugin.__init__( self, "Podcasts", "", 30 )
def rafraichir( self ):
pass # Rien a rafraichir ici...
def listerChaines( self ):
listeChaines = self.listePodcasts.keys()
listeChaines.sort()
for chaine in listeChaines:
self.ajouterChaine( chaine )
def listerEmissions( self, chaine ):
if( self.listePodcasts.has_key( chaine ) ):
self.derniereChaine = chaine
listeEmissions = self.listePodcasts[ chaine ].keys()
listeEmissions.sort()
for emission in listeEmissions:
self.ajouterEmission( chaine, emission )
def listerFichiers( self, emission ):
if( self.listePodcasts.has_key( self.derniereChaine ) ):
listeEmission = self.listePodcasts[ self.derniereChaine ]
if( listeEmission.has_key( emission ) ):
# On remet a 0 la liste des fichiers
del self.listeFichiers[ : ]
# On recupere la page de l'emission
page = urllib.urlopen( listeEmission[ emission ] )
page = page.read()
#~ page = self.API.getPage( listeEmission[ emission ] )
# Handler
handler = PodcastsHandler( self.listeFichiers )
# On parse le fichier xml
xml.sax.parseString( page, handler )
# On ajoute les fichiers
for fichier in self.listeFichiers:
self.ajouterFichier( emission, fichier )
#
# Parser XML pour les podcasts
#
## Classe qui permet de lire les fichiers XML de podcasts
class PodcastsHandler( ContentHandler ):
# Constructeur
# @param listeFichiers Liste des fichiers que le parser va remplir
def __init__( self, listeFichiers ):
# Liste des fichiers
self.listeFichiers = listeFichiers
# Url de l'image globale
self.urlImageGlobale = ""
# Initialisation des variables a Faux
self.isItem = False
self.isTitle = False
self.isDescription = False
self.isPubDate = False
self.isGuid = False
## Methode appelee lors de l'ouverture d'une balise
# @param name Nom de la balise
# @param attrs Attributs de cette balise
def startElement( self, name, attrs ):
if( name == "item" ):
self.isItem = True
self.titre = ""
self.date = ""
self.urlFichier = ""
self.urlImage = ""
self.description = ""
elif( name == "title" and self.isItem ):
self.isTitle = True
elif( name == "description" and self.isItem ):
self.isDescription = True
elif( name == "pubDate" and self.isItem ):
self.isPubDate = True
elif( name == "media:thumbnail" and self.isItem ):
self.urlImage = attrs.get( "url", "" )
elif( name == "media:content" and self.isItem ):
self.urlFichier = attrs.get( "url", "" )
elif( name == "guid" and self.isItem ):
self.isGuid = True
elif( name == "itunes:image" and not self.isItem ):
self.urlImageGlobale = attrs.get( "href", "" )
## Methode qui renvoie les donnees d'une balise
# @param data Donnees d'une balise
def characters( self, data ):
if( self.isTitle ):
self.titre += data
#~ self.isTitle = False
elif( self.isDescription ):
if( data.find( "<" ) == -1 ):
self.description += data
else:
self.isDescription = False
elif( self.isPubDate ):
self.date = data
self.isPubDate = False
elif( self.isGuid ):
self.urlFichier = data
self.isGuid = False
## Methode appelee lors de la fermeture d'une balise
# @param name Nom de la balise
def endElement( self, name ):
if( name == "item" ):
# On extrait l'extension du fichier
basename, extension = os.path.splitext( self.urlFichier )
# Si le fichier n'a pas d'image, on prend l'image globale
if( self.urlImage == "" ):
self.urlImage = self.urlImageGlobale
# On ajoute le fichier
self.listeFichiers.append( Fichier ( self.titre, self.date, self.urlFichier, self.titre + extension, self.urlImage, self.description ) )
self.isTitle = False
elif( name == "description" ):
self.isDescription = False
elif( name == "title" ):
self.isTitle = False
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier LICENSE #
#########################################
#~ Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
#~ Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
#~ Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os
from Plugin import Plugin
from Fichier import Fichier
from urllib import quote
import re,unicodedata,datetime
##########
# Classe #
##########
class Pluzz( Plugin ):
"""Classe abstraite Plugin dont doit heriter chacun des plugins"""
listeChainesEmissionsUrl = "http://www.pluzz.fr/appftv/webservices/video/catchup/getListeAutocompletion.php?support=1"
listeChainesEmissionsPattern = re.compile("chaine_principale=\"(.*?)\".*?.\[CDATA\[(.*?)\]\]")
lienEmissionBaseUrl = "http://www.pluzz.fr/"
videoInfosBaseUrl = "http://www.pluzz.fr/appftv/webservices/video/getInfosVideo.php?src=cappuccino&video-type=simple&template=ftvi&template-format=complet&id-externe="
videoTitrePattern = re.compile("titre.public><.\[CDATA\[(.*?)]]>", re.DOTALL)
videoNomPattern = re.compile("nom><.\[CDATA\[(.*?)]]>", re.DOTALL)
videoCheminPattern = re.compile("chemin><!\[CDATA\[(.*?)]]>", re.DOTALL)
videoDatePattern = re.compile("date><!\[CDATA\[(.*?)]]>", re.DOTALL)
def __init__( self):
Plugin.__init__( self, "Pluzz", "http://www.pluzz.fr/")
cache = self.chargerCache()
if cache:
self.listeChaines = cache
else:
self.listeChaines = {}
def listerOptions(self):
self.optionBouleen("france2", "Afficher France 2", True)
t = []
if self.listeChaines.has_key("france2"):
t = self.listeChaines["france2"]
t.sort()
self.optionChoixMultiple("emissionsfrance2", "Liste des émissions à afficher pour France 2", t, t)
self.optionBouleen("france3", "Afficher France 3", True)
t = []
if self.listeChaines.has_key("france3"):
t = self.listeChaines["france3"]
t.sort()
self.optionChoixMultiple("emissionsfrance3", "Liste des émissions à afficher pour France 3", t, t)
self.optionBouleen("france4", "Afficher France 4", True)
t = []
if self.listeChaines.has_key("france4"):
t = self.listeChaines["france4"]
t.sort()
self.optionChoixMultiple("emissionsfrance4", "Liste des émissions à afficher pour France 4", t, t)
self.optionBouleen("france5", "Afficher France 5", True)
t = []
if self.listeChaines.has_key("france5"):
t = self.listeChaines["france5"]
t.sort()
self.optionChoixMultiple("emissionsfrance2", "Liste des émissions à afficher pour France 5", t, t)
self.optionBouleen("franceo", "Afficher France O", True)
t = []
if self.listeChaines.has_key("franceo"):
t = self.listeChaines["franceo"]
t.sort()
self.optionChoixMultiple("emissionsfranceo", "Liste des émissions à afficher pour France O", t, t)
def rafraichir( self ):
self.listeChaines = {}
self.afficher("Récupération de la liste des émissions...")
for item in re.findall(self.listeChainesEmissionsPattern, self.API.getPage(self.listeChainesEmissionsUrl)):
if not(self.listeChaines.has_key(item[0])):
self.listeChaines[item[0]] = []
self.listeChaines[item[0]].append(item[1])
self.sauvegarderCache(self.listeChaines)
def getLienEmission(self, emission):
s = re.sub("[,: !/'\.]+", "-", emission).replace( ',', '' ).lower()
s = unicode( s, "utf8", "replace" )
s = unicodedata.normalize( 'NFD',s )
#~ return self.lienEmissionBaseUrl+unicodedata.normalize( 'NFD', s).encode( 'ascii','ignore' )+".html"
return self.lienEmissionBaseUrl+quote(s.encode( 'ascii','ignore' ))+".html"
def listerChaines( self ):
t = self.listeChaines.keys()
t.sort()
for chaine in t:
if self.getOption(chaine) == True:
self.ajouterChaine(chaine)
def listerEmissions( self, chaine ):
#~ t = []
#~ if self.listeChaines.has_key(chaine):
#~ t = self.listeChaines[chaine]
#~ t.sort()
t = self.getOption("emissions"+chaine)
if not(t):
t = []
if self.listeChaines.has_key(chaine):
t = self.listeChaines[chaine]
t.sort()
for emission in t:
self.ajouterEmission(chaine, emission)
def listerFichiers( self, emission ):
lien = self.getLienEmission(emission)
base = lien.replace(".html", "")
self.afficher("Récupération de la liste des fichiers pour \""+emission+"\"...")
dejaVue = []
nombre = 0
videos = re.findall("("+base+".+?.html)", self.API.getPage(lien));
if videos == None:
return
videos.append(lien)
for fichier in videos:
fichierInfosUrl_match = re.search(re.compile("info.francetelevisions.fr/\?id-video=(.+?)\"", re.DOTALL), self.API.getPage(fichier))
if fichierInfosUrl_match == None:
continue
fichierInfos = self.API.getPage(self.videoInfosBaseUrl+fichierInfosUrl_match.group(1))
titre = re.search(self.videoTitrePattern, fichierInfos)
if titre != None:
titre = titre.group(1)
else:
continue
nom = re.search(self.videoNomPattern, fichierInfos)
if nom != None:
nom = nom.group(1)
else:
continue
chemin = re.search(self.videoCheminPattern, fichierInfos)
if chemin != None:
chemin = chemin.group(1)
else:
continue
date = re.search(self.videoDatePattern, fichierInfos)
if date != None:
date = datetime.date.fromtimestamp(int(date.group(1))).strftime("%d/%m/%Y")
else:
continue
if titre in dejaVue:
continue
else:
dejaVue.append(titre)
lien = None
if( chemin.find( 'http' ) != -1 ):
lien = chemin + titre
elif( nom.find( 'wmv' ) != -1 ):
lien = "mms://a988.v101995.c10199.e.vm.akamaistream.net/7/988/10199/3f97c7e6/ftvigrp.download.akamai.com/10199/cappuccino/production/publication" + chemin + nom
elif( nom.find( 'mp4' ) != -1 ):
lien = "rtmp://videozones-rtmp.francetv.fr/ondemand/mp4:cappuccino/publication" + chemin + nom
if not(lien):
continue
self.ajouterFichier(emission, Fichier( titre, date, lien ) )
nombre = nombre+1
self.afficher(str(nombre)+" fichiers trouvés.")
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier LICENSE #
#########################################
#~ Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
#~ Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
#~ Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import re
import os
from Fichier import Fichier
from Plugin import Plugin
##########
# Classe #
##########
class RadioFrance( Plugin ):
listeFichiersRegEx = re.compile( '<description>([^<]+?)</description>.+?podcast09/([^"]*\.mp3)"', re.DOTALL )
listeEmissionsFranceInter = { u"Allo la planète" : "http://radiofrance-podcast.net/podcast09/rss_10121.xml",
u"Au detour du monde" : "http://radiofrance-podcast.net/podcast09/rss_10039.xml",
u"Bons baisers de Manault" : "http://radiofrance-podcast.net/podcast09/rss_11160.xml",
u"Carnet de campagne" : "http://radiofrance-podcast.net/podcast09/rss_10205.xml",
u"carrefour de l'Eco" : "http://radiofrance-podcast.net/podcast09/rss_11292.xml",
u"C'est demain la veille" : "http://radiofrance-podcast.net/podcast09/rss_11264.xml",
u"CO2 mon Amour" : "http://radiofrance-podcast.net/podcast09/rss_10006.xml",
u"Comme on nous parle" : "http://radiofrance-podcast.net/podcast09/rss_11242.xml",
u"Daniel Morin" : "http://radiofrance-podcast.net/podcast09/rss_10906.xml",
u"Didier Porte" : "http://radiofrance-podcast.net/podcast09/rss_10907.xml",
u"ECLECTIK (dimanche)" : "http://radiofrance-podcast.net/podcast09/rss_10946.xml",
u"Eclectik (samedi)" : "http://radiofrance-podcast.net/podcast09/rss_17621.xml",
u"Esprit critique" : "http://radiofrance-podcast.net/podcast09/rss_10240.xml",
u"Et pourtant elle tourne" : "http://radiofrance-podcast.net/podcast09/rss_10269.xml",
u"Histoire de..." : "http://radiofrance-podcast.net/podcast09/rss_10919.xml",
u"LA BAS, SI J'Y SUIS" : "http://radiofrance-podcast.net/podcast09/rss_14288.xml",
u"La cellule de dégrisement" : "http://radiofrance-podcast.net/podcast09/rss_11259.xml",
u"la chronique anglaise de David LOWE" : "http://radiofrance-podcast.net/podcast09/rss_11345.xml",
u"La chronique de régis Mailhot" : "http://radiofrance-podcast.net/podcast09/rss_11335.xml",
u"La chronique de Vincent Roca" : "http://radiofrance-podcast.net/podcast09/rss_11336.xml",
u"La librairie francophone" : "http://radiofrance-podcast.net/podcast09/rss_18647.xml",
u"La nuit comme si" : "http://radiofrance-podcast.net/podcast09/rss_11254.xml",
u"La presse étrangère" : "http://radiofrance-podcast.net/podcast09/rss_11331.xml",
u"Le Cinq Six Trente" : "http://radiofrance-podcast.net/podcast09/rss_10915.xml",
u"L'économie autrement" : "http://radiofrance-podcast.net/podcast09/rss_11081.xml",
u"Le débat économique" : "http://radiofrance-podcast.net/podcast09/rss_18783.xml",
u"Le jeu des mille euros" : "http://radiofrance-podcast.net/podcast09/rss_10206.xml",
u"Le journal de l'économie" : "http://radiofrance-podcast.net/podcast09/rss_10980.xml",
u"le sept neuf du dimanche" : "http://radiofrance-podcast.net/podcast09/rss_10982.xml",
u"le sept neuf du samedi" : "http://radiofrance-podcast.net/podcast09/rss_10981.xml",
u"Les grandes nuits et les petits ..." : "http://radiofrance-podcast.net/podcast09/rss_11257.xml",
u"Les savanturiers" : "http://radiofrance-podcast.net/podcast09/rss_10908.xml",
u"Le Zapping de France Inter" : "http://radiofrance-podcast.net/podcast09/rss_10309.xml",
u"L'humeur de Didier Porte" : "http://radiofrance-podcast.net/podcast09/rss_11078.xml",
u"L'humeur de François Morel" : "http://radiofrance-podcast.net/podcast09/rss_11079.xml",
u"L'humeur de Stéphane Guillon" : "http://radiofrance-podcast.net/podcast09/rss_10692.xml",
u"L'humeur vagabonde" : "http://radiofrance-podcast.net/podcast09/rss_10054.xml",
u"Noctiluque" : "http://radiofrance-podcast.net/podcast09/rss_10208.xml",
u"Nocturne" : "http://radiofrance-podcast.net/podcast09/rss_10268.xml",
u"Nonobstant" : "http://radiofrance-podcast.net/podcast09/rss_10615.xml",
u"Nous autres" : "http://radiofrance-podcast.net/podcast09/rss_18633.xml",
u"Panique au Mangin palace" : "http://radiofrance-podcast.net/podcast09/rss_10128.xml",
u"panique au ministère psychique" : "http://radiofrance-podcast.net/podcast09/rss_10905.xml",
u"Parking de nuit" : "http://radiofrance-podcast.net/podcast09/rss_10136.xml",
u"Périphéries" : "http://radiofrance-podcast.net/podcast09/rss_10040.xml",
u"Service public" : "http://radiofrance-podcast.net/podcast09/rss_10207.xml",
u"Sous les étoiles exactement" : "http://radiofrance-podcast.net/podcast09/rss_10218.xml",
u"Studio théatre" : "http://radiofrance-podcast.net/podcast09/rss_10629.xml",
u"Système disque" : "http://radiofrance-podcast.net/podcast09/rss_10093.xml",
u"Un jour sur la toile" : "http://radiofrance-podcast.net/podcast09/rss_10274.xml",
u"Un livre sous le bras" : "http://radiofrance-podcast.net/podcast09/rss_10664.xml" }
listeEmissionsFranceInfo = { u"Il était une mauvaise foi" : "http://radiofrance-podcast.net/podcast09/rss_10951.xml",
u"La vie et vous, Le chemin de l'école" : "http://radiofrance-podcast.net/podcast09/rss_11077.xml",
u"Le bruit du net" : "http://radiofrance-podcast.net/podcast09/rss_11064.xml",
u"Le droit d'info" : "http://radiofrance-podcast.net/podcast09/rss_10986.xml",
u"Le sens de l'info" : "http://radiofrance-podcast.net/podcast09/rss_10586.xml",
u"Question d'argent" : "http://radiofrance-podcast.net/podcast09/rss_10556.xml",
u"Tout comprendre" : "http://radiofrance-podcast.net/podcast09/rss_11313.xml",
u"Tout et son contraire" : "http://radiofrance-podcast.net/podcast09/rss_11171.xml" }
listeEmissionsFranceBleu = { u"1999" : "http://radiofrance-podcast.net/podcast09/rss_11325.xml",
u"C'est bon à savoir" : "http://radiofrance-podcast.net/podcast09/rss_10337.xml",
u"Chanson d'Aqui" : "http://radiofrance-podcast.net/podcast09/rss_11298.xml",
u"Club Foot Marseille" : "http://radiofrance-podcast.net/podcast09/rss_11201.xml",
u"Côté Mer" : "http://radiofrance-podcast.net/podcast09/rss_10890.xml",
u"France Bleu Midi " : "http://radiofrance-podcast.net/podcast09/rss_11204.xml",
u"Histoire en Bretagne" : "http://radiofrance-podcast.net/podcast09/rss_10638.xml",
u"La science en question" : "http://radiofrance-podcast.net/podcast09/rss_10336.xml",
u"Les défis du Professeur Gersal" : "http://radiofrance-podcast.net/podcast09/rss_11263.xml",
u"Les Français parlent aux Français" : "http://radiofrance-podcast.net/podcast09/rss_11351.xml",
u"Les nouvelles archives de l étrange" : "http://radiofrance-podcast.net/podcast09/rss_11265.xml",
u"L'horoscope" : "http://radiofrance-podcast.net/podcast09/rss_10020.xml",
u"L'humeur de Fred Ballard" : "http://radiofrance-podcast.net/podcast09/rss_11317.xml",
u"Ligne d'expert" : "http://radiofrance-podcast.net/podcast09/rss_11023.xml",
u"On repeint la musique" : "http://radiofrance-podcast.net/podcast09/rss_11268.xml",
u"Planète Bleu" : "http://radiofrance-podcast.net/podcast09/rss_11031.xml",
u"Sul gouel ha bembez..." : "http://radiofrance-podcast.net/podcast09/rss_10312.xml",
u"Tour de France 2010" : "http://radiofrance-podcast.net/podcast09/rss_11355.xml" }
listeEmissionsFranceCulture = { u"Affinités électives" : "http://radiofrance-podcast.net/podcast09/rss_10346.xml",
u"A plus d'un titre" : "http://radiofrance-podcast.net/podcast09/rss_10466.xml",
u"avec ou sans rdv" : "http://radiofrance-podcast.net/podcast09/rss_10180.xml",
u"A voix nue" : "http://radiofrance-podcast.net/podcast09/rss_10351.xml",
u"Ca rime à quoi" : "http://radiofrance-podcast.net/podcast09/rss_10897.xml",
u"Carnet Nomade" : "http://radiofrance-podcast.net/podcast09/rss_10237.xml",
u"Caroline FOUREST" : "http://radiofrance-podcast.net/podcast09/rss_10725.xml",
u"Chanson boum" : "http://radiofrance-podcast.net/podcast09/rss_10975.xml",
u"Chronique de Caroline Eliacheff" : "http://radiofrance-podcast.net/podcast09/rss_10477.xml",
u"Chronique de Cécile Ladjali" : "http://radiofrance-podcast.net/podcast09/rss_11270.xml",
u"Chronique de Clémentine Autain" : "http://radiofrance-podcast.net/podcast09/rss_10714.xml",
u"CONCORDANCE DES TEMPS" : "http://radiofrance-podcast.net/podcast09/rss_16278.xml",
u"Conférences de Michel Onfray" : "http://radiofrance-podcast.net/podcast09/rss_11141.xml",
u"Continent sciences" : "http://radiofrance-podcast.net/podcast09/rss_16256.xml",
u"Controverses du progrès (les)" : "http://radiofrance-podcast.net/podcast09/rss_11055.xml",
u"Cultures D'Islam" : "http://radiofrance-podcast.net/podcast09/rss_10073.xml",
u"Des histoires à ma façon" : "http://radiofrance-podcast.net/podcast09/rss_11181.xml",
u"Des papous dans la tête" : "http://radiofrance-podcast.net/podcast09/rss_13364.xml",
u"Divers aspects de la pensée (...)" : "http://radiofrance-podcast.net/podcast09/rss_10344.xml",
u"Du grain à moudre" : "http://radiofrance-podcast.net/podcast09/rss_10175.xml",
u"Du jour au Lendemain" : "http://radiofrance-podcast.net/podcast09/rss_10080.xml",
u"En toute franchise" : "http://radiofrance-podcast.net/podcast09/rss_10898.xml",
u"'EPOPEE DE LA FRANCE LIBRE" : "http://radiofrance-podcast.net/podcast09/rss_11365.xml",
u"Foi et tradition" : "http://radiofrance-podcast.net/podcast09/rss_10492.xml",
u"For interieur" : "http://radiofrance-podcast.net/podcast09/rss_10266.xml",
u"HORS" : "http://radiofrance-podcast.net/podcast09/rss_11189.xml",
u"Jeux d'épreuves" : "http://radiofrance-podcast.net/podcast09/rss_10083.xml",
u"La chronique d'Alexandre Adler" : "http://radiofrance-podcast.net/podcast09/rss_18810.xml",
u"La chronique de d'Alain" : "http://radiofrance-podcast.net/podcast09/rss_18809.xml",
u"La chronique d'Olivier Duhamel" : "http://radiofrance-podcast.net/podcast09/rss_18811.xml",
u"LA FABRIQUE DE L'HUMAIN" : "http://radiofrance-podcast.net/podcast09/rss_11188.xml",
u"LA MARCHE DES SCIENCES" : "http://radiofrance-podcast.net/podcast09/rss_11193.xml",
u"La messe" : "http://radiofrance-podcast.net/podcast09/rss_10272.xml",
u"La nelle fabrique de l'histoire" : "http://radiofrance-podcast.net/podcast09/rss_10076.xml",
u"La rumeur du monde" : "http://radiofrance-podcast.net/podcast09/rss_10234.xml",
u"LA SUITE DANS LES IDEES" : "http://radiofrance-podcast.net/podcast09/rss_16260.xml",
u"L'ATELIER LITTERAIRE" : "http://radiofrance-podcast.net/podcast09/rss_11185.xml",
u"LA VIGNETTE" : "http://radiofrance-podcast.net/podcast09/rss_11199.xml",
u"Le bien commun" : "http://radiofrance-podcast.net/podcast09/rss_16279.xml",
u"L'économie en question o" : "http://radiofrance-podcast.net/podcast09/rss_10081.xml",
u"Le journal de 12h30" : "http://radiofrance-podcast.net/podcast09/rss_10059.xml",
u"Le journal de 18h" : "http://radiofrance-podcast.net/podcast09/rss_10060.xml",
u"Le journal de 22h" : "http://radiofrance-podcast.net/podcast09/rss_10061.xml",
u"Le journal de 7h" : "http://radiofrance-podcast.net/podcast09/rss_10055.xml",
u"Le journal de 8h" : "http://radiofrance-podcast.net/podcast09/rss_10057.xml",
u"Le magazine de la rédaction" : "http://radiofrance-podcast.net/podcast09/rss_10084.xml",
u"LE MARDI DES AUTEURS" : "http://radiofrance-podcast.net/podcast09/rss_11194.xml",
u"Le portrait du jour par Marc Krav" : "http://radiofrance-podcast.net/podcast09/rss_18812.xml",
u"Le regard d'Albert Jacquard" : "http://radiofrance-podcast.net/podcast09/rss_16496.xml",
u"Le rendez" : "http://radiofrance-podcast.net/podcast09/rss_10082.xml",
u"Le salon noir" : "http://radiofrance-podcast.net/podcast09/rss_10267.xml",
u"Les ateliers de création radio." : "http://radiofrance-podcast.net/podcast09/rss_10185.xml",
u"Les enjeux internationaux" : "http://radiofrance-podcast.net/podcast09/rss_13305.xml",
u"LES JEUDIS DE L'EXPO" : "http://radiofrance-podcast.net/podcast09/rss_11196.xml",
u"Les lundis de l'histoire" : "http://radiofrance-podcast.net/podcast09/rss_10193.xml",
u"Les matins de France Culture" : "http://radiofrance-podcast.net/podcast09/rss_10075.xml",
u"LES MERCREDIS DU THEATRE" : "http://radiofrance-podcast.net/podcast09/rss_11195.xml",
u"Les nv chemins de la connaissance" : "http://radiofrance-podcast.net/podcast09/rss_10467.xml",
u"LES PASSAGERS DE LA NUIT" : "http://radiofrance-podcast.net/podcast09/rss_11190.xml",
u"Les Pieds sur Terre" : "http://radiofrance-podcast.net/podcast09/rss_10078.xml",
u"L'esprit public" : "http://radiofrance-podcast.net/podcast09/rss_16119.xml",
u"LES RACINES DU CIEL" : "http://radiofrance-podcast.net/podcast09/rss_11200.xml",
u"LES RETOURS DU DIMANCHE" : "http://radiofrance-podcast.net/podcast09/rss_11186.xml",
u"LES VENDREDIS DE LA MUSIQUE" : "http://radiofrance-podcast.net/podcast09/rss_11197.xml",
u"L'oeil du larynx" : "http://radiofrance-podcast.net/podcast09/rss_10311.xml",
u"MACADAM PHILO" : "http://radiofrance-podcast.net/podcast09/rss_11198.xml",
u"Maison d'études" : "http://radiofrance-podcast.net/podcast09/rss_10182.xml",
u"Masse critique" : "http://radiofrance-podcast.net/podcast09/rss_10183.xml",
u"Mauvais Genres" : "http://radiofrance-podcast.net/podcast09/rss_10070.xml",
u"MEGAHERTZ" : "http://radiofrance-podcast.net/podcast09/rss_11182.xml",
u"METROPOLITAINS" : "http://radiofrance-podcast.net/podcast09/rss_16255.xml",
u"Orthodoxie" : "http://radiofrance-podcast.net/podcast09/rss_10491.xml",
u"Place de la toile" : "http://radiofrance-podcast.net/podcast09/rss_10465.xml",
u"PLACE DES PEUPLES" : "http://radiofrance-podcast.net/podcast09/rss_11207.xml",
u"Planète terre" : "http://radiofrance-podcast.net/podcast09/rss_10233.xml",
u"POST FRONTIERE" : "http://radiofrance-podcast.net/podcast09/rss_11191.xml",
u"Projection privée" : "http://radiofrance-podcast.net/podcast09/rss_10198.xml",
u"Question d'éthique" : "http://radiofrance-podcast.net/podcast09/rss_10201.xml",
u"RADIO LIBRE" : "http://radiofrance-podcast.net/podcast09/rss_11183.xml",
u"Répliques" : "http://radiofrance-podcast.net/podcast09/rss_13397.xml",
u"Revue de presse internationale" : "http://radiofrance-podcast.net/podcast09/rss_10901.xml",
u"RUE DES ECOLES" : "http://radiofrance-podcast.net/podcast09/rss_11192.xml",
u"Science publique" : "http://radiofrance-podcast.net/podcast09/rss_10192.xml",
u"Service protestant" : "http://radiofrance-podcast.net/podcast09/rss_10297.xml",
u"Sur les docks" : "http://radiofrance-podcast.net/podcast09/rss_10177.xml",
u"Terre à terre" : "http://radiofrance-podcast.net/podcast09/rss_10867.xml",
u"TIRE TA LANGUE" : "http://radiofrance-podcast.net/podcast09/rss_11184.xml",
u"Tout arrive" : "http://radiofrance-podcast.net/podcast09/rss_10077.xml",
u"Tout un monde" : "http://radiofrance-podcast.net/podcast09/rss_10191.xml",
u"Vivre sa ville" : "http://radiofrance-podcast.net/podcast09/rss_10878.xml" }
listeEmissionsFranceMusique = { u"Histoire de..." : "http://radiofrance-podcast.net/podcast09/rss_10977.xml",
u"Le mot musical du jour" : "http://radiofrance-podcast.net/podcast09/rss_10976.xml",
u"Miniatures" : "http://radiofrance-podcast.net/podcast09/rss_10978.xml",
u"Sonnez les matines" : "http://radiofrance-podcast.net/podcast09/rss_10979.xml" }
listeEmissionsLeMouv = { u"Buzz de la semaine" : "http://radiofrance-podcast.net/podcast09/rss_10924.xml",
u"Cette année là" : "http://radiofrance-podcast.net/podcast09/rss_11280.xml",
u"Chez Francis" : "http://radiofrance-podcast.net/podcast09/rss_11285.xml",
u"Compression de Cartier" : "http://radiofrance-podcast.net/podcast09/rss_11279.xml",
u"Fausse Pub" : "http://radiofrance-podcast.net/podcast09/rss_11309.xml",
u"La BD de Philippe Audoin" : "http://radiofrance-podcast.net/podcast09/rss_11278.xml",
u"La minute culturelle de Cug et Westrou" : "http://radiofrance-podcast.net/podcast09/rss_10914.xml",
u"La minute numérique" : "http://radiofrance-podcast.net/podcast09/rss_11277.xml",
u"La mode de Samyjoe" : "http://radiofrance-podcast.net/podcast09/rss_11048.xml",
u"La Revue de Presse" : "http://radiofrance-podcast.net/podcast09/rss_11281.xml",
u"Le cinema de Jean Z" : "http://radiofrance-podcast.net/podcast09/rss_11045.xml",
u"Le Comedy Club Live" : "http://radiofrance-podcast.net/podcast09/rss_11314.xml",
u"Le meilleur du Mouv'" : "http://radiofrance-podcast.net/podcast09/rss_11274.xml",
u"L'Environnement" : "http://radiofrance-podcast.net/podcast09/rss_11041.xml",
u"Le pire de la semaine" : "http://radiofrance-podcast.net/podcast09/rss_11276.xml",
u"Le Reportage de la Redaction" : "http://radiofrance-podcast.net/podcast09/rss_11311.xml",
u"Les bons plans" : "http://radiofrance-podcast.net/podcast09/rss_11273.xml",
u"Les lectures de Clementine" : "http://radiofrance-podcast.net/podcast09/rss_11051.xml",
u"Les séries TV de Pierre Langlais" : "http://radiofrance-podcast.net/podcast09/rss_11288.xml",
u"Le Top 3 d'Emilie" : "http://radiofrance-podcast.net/podcast09/rss_11287.xml",
u"Le tour du Web" : "http://radiofrance-podcast.net/podcast09/rss_10926.xml",
u"L'invité du Mouv'" : "http://radiofrance-podcast.net/podcast09/rss_11330.xml",
u"L'invité matinal" : "http://radiofrance-podcast.net/podcast09/rss_11286.xml",
u"Revue de Web" : "http://radiofrance-podcast.net/podcast09/rss_11310.xml",
u"Un grand verre d'Orangeade" : "http://radiofrance-podcast.net/podcast09/rss_11282.xml",
u"Un tir dans la lucarne" : "http://radiofrance-podcast.net/podcast09/rss_11289.xml",
u"Zebra" : "http://radiofrance-podcast.net/podcast09/rss_11308.xml" }
listeEmissions = { "France Inter" : listeEmissionsFranceInter,
"France Info" : listeEmissionsFranceInfo,
"France Bleu" : listeEmissionsFranceBleu,
"France Culture" : listeEmissionsFranceCulture,
"France Musique" : listeEmissionsFranceMusique,
"Le Mouv'" : listeEmissionsLeMouv }
def __init__( self):
Plugin.__init__( self, "Radio France", "http://www.radiofrance.fr/", 30 )
def rafraichir( self ):
pass # Rien a rafraichir ici...
def listerChaines( self ):
liste = self.listeEmissions.keys()
liste.sort()
for chaine in liste:
self.ajouterChaine(chaine)
def listerEmissions( self, chaine ):
self.derniereChaine = chaine
liste = []
if( chaine != "" ):
liste = self.listeEmissions[ chaine ].keys()
liste.sort()
for emission in liste:
self.ajouterEmission(chaine, emission)
def listerFichiers( self, emission ):
if( emission != "" ):
if( emission in self.listeEmissions[ self.derniereChaine ] ):
# On recupere le lien de la page de l'emission
lienPage = self.listeEmissions[ self.derniereChaine ][ emission ]
# On recupere la page de l'emission
page = self.API.getPage( lienPage )
# On recupere le lien de l'image de l'emission
try :
urlImage = re.findall( '<itunes:image href="([^"]+?)"', page )[ 0 ]
except :
urlImage = ""
# On extrait les emissions
resultats = re.findall( self.listeFichiersRegEx, page )
for ( descriptif, fichier ) in resultats:
lien = "http://media.radiofrance-podcast.net/podcast09/" + fichier
listeDates = re.findall( "\d{2}\.\d{2}\.\d{2}", fichier )
if( listeDates == [] ): # Si on n'a pas pu extraire une date
date = "Inconnue"
else: # Si on a extrait une date
date = listeDates[ 0 ]
self.ajouterFichier(emission, Fichier( emission + " (" + date + ")", date, lien, urlImage = urlImage, descriptif = descriptif ) )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os
from Plugin import Plugin
from Fichier import Fichier
from urllib import quote,unquote
import re,unicodedata
import time,rfc822 # for RFC822 datetime format (rss feed)
from datetime import datetime
from htmlentitydefs import name2codepoint
##########
# Classe #
##########
class Arte(Plugin):
##
## Arte Live Web
##
configArteLiveWeb = {
'nom' : "Arte Live Web",
'qualite' : ['SD', 'HD', 'Live'],
'regexEmissions' : {
'url' : "http://liveweb.arte.tv/",
# Attention à bien nommer les zones de recherche "lien" et "nom"
'pattern' : re.compile("<li><a href=\"http://liveweb.arte.tv/fr/cat/(?P<lien>.*?)\" class=\"accueil\">(?P<nom>.*?)</a></li>", re.DOTALL)
},
'regexListeFichiers' : {
0 : {
# %emission% représente l'émission à lister
'url' : "http://liveweb.arte.tv/fr/cat/%emission%",
'pattern' : re.compile("<a href=\"(http://download.liveweb.arte.tv/o21/liveweb/rss/home.*?\.rss)\"", re.DOTALL)
},
1 : {
# %pattern% représente le résultat de l'expression régulière précédente
'url' : "%pattern%",
# Expression régulière pour extraire les blocs descriptifs de chaque fichier
'pattern' : re.compile("(<item>.*?</item>)", re.DOTALL)
},
},
'regexInfosFichiers' : {
0 : {
# Premère regex, ne se base pas sur une URL mais sur les données extraites par regexListeFichiers
# Liste des informations à récupérer
'patterns' : {
'titre' : re.compile("<title>(.*?)</title>", re.DOTALL),
'lien' : re.compile("<link>(http://liveweb.arte.tv/fr/video/.*?)</link>", re.DOTALL),
'date' : re.compile("<pubDate>(.*?)</pubDate>", re.DOTALL),
'description' : re.compile("<description>(.*?)</description>", re.DOTALL),
#'eventid' : re.compile("<enclosure.*?/event/(.*?)/.*?/>", re.DOTALL),
'eventid' : re.compile("<enclosure.*?/event/.*?/(.*?)-.*?/>", re.DOTALL)
}
},
1 : {
# Les variables %xxx% sont remplacées par les éléments déjà trouvés via les expressions précédentes
'url' : "%lien%",
# optional = 1, cette étape n'est pas exécutée en mode TURBO
'optional' : 1,
# Liste des informations à récupérer
'patterns' : {
'eventid_html': re.compile("new LwEvent\('(.*?)', ''\);", re.DOTALL)
},
},
2 : {
# Les variables %xxx% sont remplacées par les éléments déjà trouvés via les expressions précédentes
'url' : "http://arte.vo.llnwd.net/o21/liveweb/events/event-%eventid%.xml",
# Liste des informations à récupérer
'patterns' : {
'titre' : re.compile("<nameFr>(.*?)</nameFr>", re.DOTALL),
'lien.HD': re.compile("<urlHd>(.*?)</urlHd>", re.DOTALL),
'lien.SD': re.compile("<urlSd>(.*?)</urlSd>", re.DOTALL),
'lien.Live': re.compile("<liveUrl>(.*?)</liveUrl>", re.DOTALL)
},
},
},
'infosFichier' : {
'nom' : "[%qualite%] %titre%",
'date' : "%date%",
'lien' : "%lien%",
#'nomFichierSortieStd' : "%lien%",
#'nomFichierSortieRen' : "%titre%",
#~ 'urlImage' : "http://download.liveweb.arte.tv/o21/liveweb/media/event/%eventid%/%eventid%-visual-cropcropcrop-small.jpg",
'urlImage' : "http://download.liveweb.arte.tv/o21/liveweb/media/event/%eventid%/%eventid%-visual.jpg",
'descriptif' : "%description%"
}
}
##
## Arte+7
##
# En cas de souci, on pourrait utiliser la page RSS de chaque chaine
# Pour récupérer la liste des chaines (càd la liste des flux RSS)
# http://videos.arte.tv/fr/videos/meta/index-3188674-3223978.html
# Pour récupérer la liste des émissions d'une chaine
# http://videos.arte.tv/fr/do_delegate/videos/programmes/360_geo/index-3188704,view,rss.xml
configArtePlusSept = {
'nom' : "Arte+7",
'qualite' : ['SD', 'HD'],
'regexEmissions' : {
'url' : "http://videos.arte.tv/fr/videos",
# Attention à bien nommer les zones de recherche "lien" et "nom"
'pattern' : re.compile("<input type=\"checkbox\" value=\"(?P<lien>.*?)\"/>.*?<a href=\"#\">(?P<nom>.*?)</a>", re.DOTALL)
},
'regexListeFichiers' : {
0 : {
# %emission% représente l'émission à lister
'url' : "http://videos.arte.tv/fr/do_delegate/videos/index-%emission%-3188698,view,asList.html?hash=fr/list/date//1/250/",
# Expression régulière pour extraire les blocs descriptifs de chaque vidéo
'pattern' : re.compile("(<tr.*?>.*?</tr>)", re.DOTALL)
},
},
'regexInfosFichiers' : {
0 : {
# Premère regex, ne se base pas sur une URL mais sur les données extraites par regexListeFichiers
# Liste des informations à récupérer
# Les expressions de type texte %xxx% sont remplacées par les options du plugin (choix arbitraire pour l'instant)
'patterns' : {
'titre' : re.compile("title=\"(.*?)\|\|", re.DOTALL),
'lien' : re.compile("<a href=\"/(fr/videos/.*?\.html)\">", re.DOTALL),
'date' : re.compile("<em>(.*?)</em>", re.DOTALL),
'description' : re.compile("\|\|(.*?)\">", re.DOTALL),
'guid' : re.compile("{ajaxUrl:'.*-(.*?).html", re.DOTALL),
'player_swf' : "%default_playerSWF%",
}
},
1 : {
# Les variables %xxx% sont remplacées par les éléments déjà trouvés via les expressions précédentes
'url' : "http://videos.arte.tv/%lien%",
# optional = 1, cette étape n'est pas exécutée en mode TURBO
'optional' : 1,
# Liste des informations à récupérer
'patterns' : {
'player_swf' : re.compile("<param name=\"movie\" value=\"(.*?\.swf)", re.DOTALL),
'titre' : re.compile("<div class=\"recentTracksMast\">.*?<h3>(.*?)</h3>.*?</div>", re.DOTALL),
'image' : re.compile("<link rel=\"image_src\" href=\"(.*?)\"/>", re.DOTALL),
'description' : re.compile("<div class=\"recentTracksCont\">.*?<div>(.*?)</div>", re.DOTALL),
'guid': re.compile("addToPlaylistOpen {ajaxUrl:'/fr/do_addToPlaylist/videos/.*?-(.*?)\.html'}", re.DOTALL)
},
},
2 : {
# Les variables %xxx% sont remplacées par les éléments déjà trouvés via les expressions précédentes
'url' : "http://videos.arte.tv/fr/do_delegate/videos/-%guid%,view,asPlayerXml.xml",
# Liste des informations à récupérer
'patterns' : {
'titre' : re.compile("<name>(.*?)</name>", re.DOTALL),
'date' : re.compile("<dateVideo>(.*?)</dateVideo>", re.DOTALL),
'image' : re.compile("<firstThumbnailUrl>(.*?)</firstThumbnailUrl>", re.DOTALL),
'lien.HD': re.compile("<url quality=\"hd\">(.*?)</url>", re.DOTALL),
'lien.SD': re.compile("<url quality=\"sd\">(.*?)</url>", re.DOTALL),
},
},
},
'infosFichier' : {
'nom' : "[%qualite%] %titre%",
'date' : "%date%",
'lien' : "%lien% -W %player_swf%",
#'nomFichierSortieStd' : "%lien%.mp4",
#'nomFichierSortieRen' : "%titre%",
'urlImage' : "%image%",
'descriptif' : "%description%"
}
}
##
## Options du plugin
##
listeOptions = {
0: {
# Qualité à rechercher SD ou HD ?
'type' : "ChoixUnique",
'nom' : "qualite",
'description' : "Qualité des vidéos",
'defaut' : "HD",
'valeurs' : ["HD", "SD","HD & SD"],
},
1: {
# Nombre maximum de fichiers à rechercher (0 = aucune limite)
'type' : "Texte",
'nom' : "max_files",
'description' : "Nombre d'enregistrements à analyser\n(0=pas de limite)",
'defaut' : "20",
},
2: {
# Renommer les fichiers à partir du titre de l'émission
'type' : "Bouleen",
'nom' : "rename_files",
'description' : "Renommer les fichiers à partir du titre de l'émission\nATTENTION : plusieurs enregistrements peuvent avoir le même nom",
'defaut' : False,
},
3: {
# Mode turbo : charge moins de pages, donc plus rapide, mais moins de détails
'type' : "Bouleen",
'nom' : "turbo_mode",
'description' : "Mode TURBO\nChargement plus rapide mais informations moins détaillées",
'defaut' : False,
},
4: {
# PlayerSWF par default pour Arte+7
'type' : "Texte",
'nom' : "default_playerSWF",
'description' : "Player Arte+7 à utiliser par défaut (en mode TURBO)\nATTENTION : Réservé aux utilisateurs avancés",
'defaut' : "http://videos.arte.tv/blob/web/i18n/view/player_11-3188338-data-4785094.swf",
}
}
nom = "Arte"
url = "http://www.arte.tv/"
listeChaines = {} # Clef = Nom Chaine, Valeur = { Nom emission : Lien }
# Supprime les caractères spéciaux HTML du tyle &#nn;
# http://www.w3.org/QA/2008/04/unescape-html-entities-python.html
# http://bytes.com/topic/python/answers/21074-unescaping-xml-escape-codes
def htmlent2chr(self, s):
def ent2chr(m):
code = m.group(1)
if code.isdigit(): code = int(code)
else: code = int(code[1:], 16)
if code<256: return chr(code)
else: return '?' #XXX unichr(code).encode('utf-16le') ??
return re.sub(r'\&\#(x?[0-9a-fA-F]+);', ent2chr, s)
# Supprime les caractères spéciaux HTML
# http://wiki.python.org/moin/EscapingHtml
def htmlentitydecode(self, s):
return re.sub('&(%s);' % '|'.join(name2codepoint),
lambda m: unichr(name2codepoint[m.group(1)]), s)
# Supprime les caractères spéciaux pour obtenir un nom de fichier correct
def cleanup_filename (self, s):
nouvNom = s
nouvNom = nouvNom.replace(" ","_")
nouvNom = nouvNom.replace(":","_")
nouvNom = nouvNom.replace("/","_")
nouvNom = nouvNom.replace("\\","_")
nouvNom = nouvNom.replace("?","_")
return nouvNom
# Fonction parse_date recopiée de l'application arte+7recorder
# Permet de convertir une date issue d'Arte+7 (hier, aujourd'hui...) en vrai date
def parse_date(self, date_str):
time_re = re.compile("^\d\d[h:]\d\d$")
fr_monthesL = ["janvier", "février", "mars", "avril", "mai", "juin", "juillet", "août", "septembre", "octobre", "novembre", "décembre"]
fr_monthesC = ["janv.", "fevr.", "mars", "avr.", "mai", "juin", "juil.", "août", "sept.", "oct.", "nov.", "déc."]
de_monthes = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"]
date_array = date_str.split(",")
if time_re.search(date_array[-1].strip()) is None:
return ""
time_ = date_array[-1].strip()
if date_array[0].strip() in ("Aujourd'hui", "Heute"):
date_ = time.strftime("%Y/%m/%d")
elif date_array[0].strip() in ("Hier", "Gestern"):
date_ = time.strftime("%Y/%m/%d", time.localtime(time.time() - (24*60*60)))
else:
array = date_array[1].split()
day = array[0].strip(".")
month = array[1]
for arr in (fr_monthesL, fr_monthesC, de_monthes):
if array[1] in arr:
month = "%02d" % (arr.index(array[1])+1)
year = array[2]
date_ = "%s/%s/%s" % (year, month, day)
return date_ + ", " + time_
def __init__(self):
Plugin.__init__(self, self.nom, self.url, 7) #7 = fréquence de rafraichissement
if os.path.exists(self.fichierCache):
self.listeChaines = self.chargerCache()
def debug_savefile (self, buffer):
path = os.path.expanduser( "~" )
fichierDebug = path+"/.tvdownloader/"+self.nom.replace( " ", "_" )+".log"
file = open(fichierDebug, "w")
file.write (buffer)
file.close()
def debug_print (self, variable):
#~ print str(variable).replace("},", "},\n\n").replace("',", "',\n").replace("\",", "\",\n")
print str(variable).replace("{", "\n\n{").replace(", ", ",\n")
def listerOptions(self):
for option in self.listeOptions.values():
if option['type']=="ChoixUnique":
self.optionChoixUnique(option['nom'], option['description'], option['defaut'], option['valeurs'])
elif option['type']=="ChoixMultiple":
self.optionChoixMultiple(option['nom'], option['description'], option['defaut'], option['valeurs'])
elif option['type']=="Texte":
self.optionTexte(option['nom'], option['description'], option['defaut'])
elif option['type']=="Bouleen":
self.optionBouleen(option['nom'], option['description'], option['defaut'])
def rafraichir(self):
self.afficher("Global : Création de la liste des chaines...")
# On remet a 0 la liste des chaines
self.listeChaines.clear()
# On boucle sur chaque "chaine" à analyser
for chaineActuelle in [self.configArteLiveWeb, self.configArtePlusSept]:
self.afficher (chaineActuelle['nom']+" Récupération de la liste des catégories "+chaineActuelle['nom']+"...")
listeEmissions = {}
# On recherche toutes les catégories
for item in re.finditer(chaineActuelle['regexEmissions']['pattern'], self.API.getPage(chaineActuelle['regexEmissions']['url'])):
self.afficher (chaineActuelle['nom']+" ... Catégorie "+item.group('nom')+" : "+item.group('lien')+".")
listeEmissions[item.group('nom')]=item.group('lien')
self.listeChaines[chaineActuelle['nom']] = listeEmissions
# On sauvegarde les chaines trouvées
self.listerOptions()
self.sauvegarderCache(self.listeChaines)
self.afficher("Global : Emissions conservées.")
def listerChaines(self):
liste = self.listeChaines.keys()
liste.sort()
for chaine in liste:
self.ajouterChaine(chaine)
def listerEmissions(self, chaine):
if(self.listeChaines.has_key(chaine)):
self.derniereChaine = chaine
liste = self.listeChaines[chaine].keys()
liste.sort()
for emission in liste:
self.ajouterEmission(chaine, emission)
def getLienEmission(self, emission):
# Cherche dans quelle chaine se trouve l'émission
if(self.listeChaines.has_key(self.derniereChaine)):
listeEmissions = self.listeChaines[ self.derniereChaine ]
if(listeEmissions.has_key(emission)):
return listeEmissions[ emission ]
def chargeListeEnregistrements(self, emission, chaineActuelle):
emissionID = self.getLienEmission(emission)
if emissionID == None:
self.afficher (chaineActuelle['nom']+" Erreur de recherche du lien pour \""+emission+"\"")
return None
else:
self.afficher (chaineActuelle['nom']+" Liste des enregistrements pour \""+emission+"\"...")
pattern = ""
for unItem in chaineActuelle['regexListeFichiers'].values():
#~ print str(chaineActuelle['regexListeFichiers'])
# Construction du lien contenant toutes les émissions de cette catégorie
lienPage = unItem['url'].replace("%emission%", emissionID).replace("%pattern%", pattern)
self.afficher (chaineActuelle['nom']+" ... lecture de la page "+lienPage)
laPage = self.API.getPage(lienPage)
if len(laPage)>0:
foundItems = re.findall(unItem['pattern'], laPage)
pattern = foundItems[0]
self.afficher (chaineActuelle['nom']+" On a listé " + str(len(foundItems)) + " enregistrements.")
else:
self.afficher (chaineActuelle['nom']+" Impossible de charger la page. Aucun enregistrement trouvé !")
foundItems = None
return foundItems
def ajouteFichiers (self, emission, listeEnregistrement, chaineActuelle):
self.afficher (chaineActuelle['nom']+" On ajoute les enregitrements trouvés.")
opt_renameFiles = self.getOption("rename_files")
opt_qual = self.getOption("qualite")
nbLiens = 0
for keyEnregistrement in listeEnregistrement.keys():
# on supprime l'enregistrement avec son index actuel
unEnregistrement = listeEnregistrement.copy()[keyEnregistrement]
for infosQualite in chaineActuelle['qualite']:
infosFichier = {}
if opt_qual.find(infosQualite)>=0:
# Lien dans la qualité voulue
unEnregistrement['lien'] = unEnregistrement.get('lien.'+infosQualite, None)
if unEnregistrement['lien'] == None:
self.afficher (chaineActuelle['nom']+" ... Pas de lien "+infosQualite+" trouvé.")
continue
# Date, mise en forme
rfc_date = rfc822.parsedate(unEnregistrement['date'])
# Format année/mois/jour hh:mm, mieux pour effectuer un tri
unEnregistrement['date'] = time.strftime("%Y/%m/%d %H:%M", rfc_date)
lesInfos = {}
for keyInfo in chaineActuelle['infosFichier'].keys():
uneInfo = chaineActuelle['infosFichier'][keyInfo]
# On effectue les remplacements selon les informations collectées
for unTag in unEnregistrement.keys():
if unEnregistrement[unTag] != None:
uneInfo = uneInfo.replace("%"+unTag+"%", unEnregistrement[unTag])
else:
uneInfo = uneInfo.replace("%"+unTag+"%", "")
# Qualité de la video
uneInfo = uneInfo.replace("%qualite%", infosQualite)
lesInfos[keyInfo] = uneInfo
# Nom fichier
if opt_renameFiles:
nomFichierSortie = self.cleanup_filename(unEnregistrement['titre'])
else:
nomFichierSortie = unEnregistrement['lien'].split('/')[-1]
if nomFichierSortie.find('?')>0:
nomFichierSortie = nomFichierSortie.split('?')[0]
if not re.match(".*\.mp4", nomFichierSortie):
nomFichierSortie = nomFichierSortie+".mp4"
# Ajout du fichier
nbLiens += 1
self.afficher (chaineActuelle['nom']+" Ajoute dans la liste...")
self.afficher (chaineActuelle['nom']+" ... Date : "+ lesInfos['date'])
self.afficher (chaineActuelle['nom']+" ... Nom : "+ lesInfos['nom'])
self.afficher (chaineActuelle['nom']+" ... Lien : " + lesInfos['lien'])
self.afficher (chaineActuelle['nom']+" ... Image : " + lesInfos['urlImage'])
self.afficher (chaineActuelle['nom']+" ... Nom fichier : " + nomFichierSortie)
leFichier = Fichier(
lesInfos['nom'],
lesInfos['date'],
lesInfos['lien'],
nomFichierSortie,
lesInfos['urlImage'],
lesInfos['descriptif']
)
self.ajouterFichier(emission, leFichier)
return nbLiens
def listerEnregistrements(self, emission, chaineActuelle):
opt_maxFiles = int(self.getOption("max_files"))
opt_turbo = self.getOption("turbo_mode")
nbLiens = 0
# Charge la page contenant la liste des émissions
videosList = self.chargeListeEnregistrements(emission, chaineActuelle)
# A-t-on une liste d'enregistrements ?
if videosList != None:
listeEnregistrement = {}
# Boucle sur chaque traitement de recherche
for unItem in chaineActuelle['regexInfosFichiers'].values():
optional = unItem.get('optional',0)
if not (opt_turbo and optional):
if unItem.get('url', None) == None:
# On n'a pas d'url, on travaille sur videoList
# C'est la première passe
nbFichiers = 0
lesPages = {}
for infosVideo in videosList:
lesPages[nbFichiers] = infosVideo
# On crée, et on indexe listeEnregistrement en phase avec videosList
listeEnregistrement[nbFichiers] = {}
nbFichiers += 1
if (opt_maxFiles>0 and nbFichiers>=opt_maxFiles):
break
else:
# Chargement des pages HTML sur lesquelles on va devoir travailler
self.afficher (chaineActuelle['nom']+" Chargement des pages nécessaires...")
listeURL = []
# On boucle sur chaque enregistrement à travailler
for keyEnregistrement in listeEnregistrement.keys():
# on supprime l'enregistrement avec son index actuel
unEnregistrement = listeEnregistrement.pop (keyEnregistrement)
lienHTML = unItem['url']
# On effectue les remplacements des paramètres dans l'url
for unTag in unEnregistrement.keys():
if unEnregistrement[unTag] != None:
lienHTML = lienHTML.replace("%"+unTag+"%", unEnregistrement[unTag])
else:
lienHTML = lienHTML.replace("%"+unTag+"%", "")
listeURL.append(lienHTML)
# on recrée l'enregistrement avec son nouvel index
listeEnregistrement[lienHTML] = unEnregistrement
# On charge les pages désirées
lesPages = self.API.getPages(listeURL)
# On boucle et exécute les expressions régulières
for pageNum in lesPages.keys():
unePage = lesPages[pageNum]
if len(unePage)==0:
self.afficher (chaineActuelle['nom']+" ERREUR : La page "+pageNum+" n'a pas été chargée !")
#~ print "Page : "+repr(unePage)
unEnregistrement = listeEnregistrement[pageNum]
for unTag in unItem['patterns'].keys():
if type(unItem['patterns'][unTag]).__name__==type(re.compile("foo")).__name__:
reFound = re.search(unItem['patterns'][unTag], unePage)
if reFound != None:
unEnregistrement[unTag] = reFound.group(1)
else:
unEnregistrement[unTag] = None
else:
texte = unItem['patterns'][unTag]
for option in self.listeOptions.values():
texte = texte.replace("%"+option['nom']+"%", str(self.getOption(option['nom'])))
unEnregistrement[unTag] = texte
# On ajoute enfin la liste des fichiers à télécharger
nbLiens = self.ajouteFichiers(emission, listeEnregistrement, chaineActuelle)
def listerFichiers(self, emission):
for chaineActuelle in [self.configArteLiveWeb, self.configArtePlusSept]:
if (self.derniereChaine == chaineActuelle['nom']):
self.listerEnregistrements (emission, chaineActuelle) | Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import re
import os
import os.path
import pickle
import base64
from Crypto.Cipher import DES
import xml.sax
from xml.sax.handler import ContentHandler
import unicodedata
from Fichier import Fichier
from Plugin import Plugin
###########
# Classes #
###########
class M6Replay( Plugin ):
def __init__( self ):
Plugin.__init__( self, "M6Replay", "www.m6replay.fr/", 1 )
self.listeFichiers = {} # Clefs = nomChaine, Valeurs = { nomEmission, [ [ Episode 1, Date1, URL1 ], ... ] }
if os.path.exists( self.fichierCache ):
self.listeFichiers = self.chargerCache()
def rafraichir( self ):
self.afficher( u"Récupération de la liste des émissions..." )
# On remet a 0 la liste des fichiers
self.listeFichiers.clear()
# On recupere la page qui contient les donnees chiffrees
pageEmissionsChiffree = self.API.getPage( "http://www.m6replay.fr/catalogue/catalogueWeb3.xml" )
#
# N.B. : La page http://www.m6replay.fr/catalogue/catalogueWeb4.xml semble contenir
# des videos non presentent sur le site...
# Il faudrait voir ce qu'il en retourne (pourquoi ne sont-elles pas sur le site ? les liens fonctionnent-ils ?)
#
# Classe pour dechiffrer la page
decryptor = DES.new( "ElFsg.Ot", DES.MODE_ECB )
# Page des emissions dechiffree
pageEmissions = decryptor.decrypt( base64.decodestring( pageEmissionsChiffree ) )
# On cherche la fin du fichier XML
finXML = pageEmissions.find( "</template_exchange_WEB>" ) + len( "</template_exchange_WEB>" )
# On enleve ce qui est apres la fin du fichier XML
pageEmissions = pageEmissions[ : finXML ]
# Handler
handler = M6ReplayHandler( self.listeFichiers )
# On parse le fichier xml
xml.sax.parseString( pageEmissions, handler )
self.sauvegarderCache( self.listeFichiers )
self.afficher( "Fichier sauvegarde" )
def listerChaines( self ):
for chaine in self.listeFichiers.keys():
self.ajouterChaine( chaine )
def listerEmissions( self, chaine ):
if( self.listeFichiers.has_key( chaine ) ):
self.listeEmissionsCourantes = self.listeFichiers[ chaine ]
for emission in self.listeFichiers[ chaine ].keys():
self.ajouterEmission( chaine, emission )
def listerFichiers( self, emission ):
if( self.listeEmissionsCourantes.has_key( emission ) ):
listeFichiers = self.listeEmissionsCourantes[ emission ]
for ( nom, date, lien, urlImage, descriptif ) in listeFichiers:
lienValide = "rtmpe://m6dev.fcod.llnwd.net:443/a3100/d1/mp4:production/regienum/" + lien
urlImage = "http://images.m6replay.fr" + urlImage
# On extrait l'extension du fichier
basename, extension = os.path.splitext( lien )
self.ajouterFichier( emission, Fichier( nom, date, lienValide, nom + extension, urlImage, descriptif ) )
#
# Parser XML pour M6Replay
#
## Classe qui permet de lire les fichiers XML de M6Replay
class M6ReplayHandler( ContentHandler ):
# Constructeur
# @param listeFichiers Liste des fichiers que le parser va remplir
def __init__( self, listeFichiers ):
# Liste des fichiers
self.listeFichiers = listeFichiers
# Liste des emissions (temporaire, ajoute au fur et a mesure dans listeFichiers)
self.listeEmissions = {}
# Liste des videos (temporaire, ajoute au fur et a mesure dans listeEmissions)
self.listeVideos = []
# Initialisation des variables a Faux
self.nomChaineConnu = False
self.nomEmissionConnu = False
self.nomEpisodeConnu = False
self.nomVideoConnu = False
self.isNomChaine = False
self.isNomEmission = False
self.isNomEpisode = False
self.isNomVideo = False
self.isResume = False
## Methode appelee lors de l'ouverture d'une balise
# @param name Nom de la balise
# @param attrs Attributs de cette balise
def startElement( self, name, attrs ):
if( name == "categorie" ):
if( self.nomChaineConnu ):
# On commence une nouvelle emission
pass
else:
# On commence une nouvelle chaine
pass
elif( name == "nom" ):
# Si on a nom, cela peut etre (toujours dans cet ordre) :
# - Le nom de la chaine
# - Le nom de l'emission
# - Le nom d'un episode de cette emission
# - Le nom de la vidéo de cet episode
# De plus, si on ne connait pas la nom de la chaine, alors le 1er nom rencontre est le nom de la chaine
if( self.nomChaineConnu ):
if( self.nomEmissionConnu ):
if( self.nomEpisodeConnu ): # Alors on a le nom de la video
self.isNomVideo = True
else: # Alors on a le nom de l'episode
self.isNomEpisode = True
else: # Alors on a le nom de l'emission
self.isNomEmission = True
else: # Alors on a le nom de la chaine
self.isNomChaine = True
elif( name == "diffusion" ):
self.dateEpisode = attrs.get( "date", "" )
elif( name == "resume" ):
self.isResume = True
elif( name == "produit" ):
self.image = attrs.get( "sml_img_url", "" )
## Methode qui renvoie les donnees d'une balise
# @param data Donnees d'une balise
def characters( self, data ):
data = unicodedata.normalize( 'NFKD', data ).encode( 'ascii','ignore' )
if( self.isNomChaine ):
self.nomChaine = data
self.nomChaineConnu = True
self.isNomChaine = False
elif( self.isNomEmission ):
self.nomEmission = data
self.nomEmissionConnu = True
self.isNomEmission = False
elif( self.isNomEpisode ):
self.nomEpisode = data
self.nomEpisodeConnu = True
self.isNomEpisode = False
elif( self.isNomVideo ):
self.nomVideo = data
self.nomVideoConnu = True
self.isNomVideo = False
elif( self.isResume ):
self.resume = data
self.isResume = False
## Methode appelee lors de la fermeture d'une balise
# @param name Nom de la balise
def endElement( self, name ):
if( name == "categorie" ):
if( self.nomEmissionConnu ): # On a fini de traiter une emission
self.listeEmissions[ self.nomEmission.title() ] = self.listeVideos
self.listeVideos = []
self.nomEmissionConnu = False
else: # On a fini de traiter une chaine
self.listeFichiers[ self.nomChaine.title() ] = self.listeEmissions
self.listeEmissions = {}
self.nomChaineConnu = False
elif( name == "nom" ):
pass
elif( name == "diffusion" ):
self.listeVideos.append( [ self.nomEpisode.title(), self.dateEpisode, self.nomVideo, self.image, self.resume ] )
self.nomEpisodeConnu = False
self.nomVideoConnu = False
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import re
import os
import os.path
import pickle
import xml.sax
from xml.sax.handler import ContentHandler
import urllib
import unicodedata
from Fichier import Fichier
from Plugin import Plugin
###########
# Classes #
###########
class W9Replay( Plugin ):
urlFichierXML = "http://data.w9replay.fr/catalogue/120-w9.xml"
listeFichiers = {} # Clefs = nomChaine, Valeurs = { nomEmission, [ [ Episode 1, Date1, URL1 ], ... ] }
def __init__( self ):
Plugin.__init__( self, "W9Replay", "http://www.w9replay.fr/", 1 )
self.listeEmissionsCourantes = {}
if os.path.exists( self.fichierCache ):
self.listeFichiers = self.chargerCache()
def rafraichir( self ):
self.afficher( u"Récupération de la liste des émissions et des fichiers..." )
# On remet a 0 la liste des fichiers
self.listeFichiers.clear()
# On recupere la page qui contient les infos
page = urllib.urlopen( self.urlFichierXML )
pageXML = page.read()
#~ pageXML = self.API.getPage( self.urlFichierXML )
# Handler
handler = W9ReplayHandler( self.listeFichiers )
# On parse le fichier xml
xml.sax.parseString( pageXML, handler )
self.sauvegarderCache( self.listeFichiers )
self.afficher( u"Liste sauvegardée" )
def listerChaines( self ):
for chaine in self.listeFichiers.keys():
self.ajouterChaine( chaine )
def listerEmissions( self, chaine ):
if( self.listeFichiers.has_key( chaine ) ):
self.listeEmissionsCourantes = self.listeFichiers[ chaine ]
for emission in self.listeEmissionsCourantes.keys():
self.ajouterEmission( chaine, emission )
def listerFichiers( self, emission ):
if( self.listeEmissionsCourantes.has_key( emission ) ):
listeFichiers = self.listeEmissionsCourantes[ emission ]
for ( nom, date, lien, urlImage, descriptif ) in listeFichiers:
lienValide = "rtmpe://m6dev.fcod.llnwd.net:443/a3100/d1/mp4:production/w9replay/" + lien
urlImage = "http://images.w9replay.fr" + urlImage
# On extrait l'extension du fichier
basename, extension = os.path.splitext( lien )
self.ajouterFichier( emission, Fichier( nom, date, lienValide, nom + extension, urlImage, descriptif ) )
#
# Parser XML pour W9Replay
#
## Classe qui permet de lire les fichiers XML de W9Replay
class W9ReplayHandler( ContentHandler ):
# Constructeur
# @param listeFichiers Liste des fichiers que le parser va remplir
def __init__( self, listeFichiers ):
# Liste des fichiers
self.listeFichiers = listeFichiers
# Liste des emissions (temporaire, ajoute au fur et a mesure dans listeFichiers)
self.listeEmissions = {}
# Liste des videos (temporaire, ajoute au fur et a mesure dans listeEmissions)
self.listeVideos = []
# Initialisation des variables a Faux
self.nomChaineConnu = False
self.nomEmissionConnu = False
self.nomEpisodeConnu = False
self.nomVideoConnu = False
self.isNomChaine = False
self.isNomEmission = False
self.isNomEpisode = False
self.isNomVideo = False
self.isResume = False
## Methode appelee lors de l'ouverture d'une balise
# @param name Nom de la balise
# @param attrs Attributs de cette balise
def startElement( self, name, attrs ):
if( name == "categorie" ):
if( self.nomChaineConnu ):
# On commence une nouvelle emission
pass
else:
# On commence une nouvelle chaine
pass
elif( name == "nom" ):
# Si on a nom, cela peut etre (toujours dans cet ordre) :
# - Le nom de l'emission
# - Le nom d'un episode de cette emission
# - Le nom de la vidéo de cet episode
# De plus, si on ne connait pas la nom de la chaine, alors le 1er nom rencontre est le nom de la chaine
if( self.nomChaineConnu ):
if( self.nomEmissionConnu ):
if( self.nomEpisodeConnu ): # Alors on a le nom de la video
self.isNomVideo = True
else: # Alors on a le nom de l'episode
self.isNomEpisode = True
else: # Alors on a le nom de l'emission
self.isNomEmission = True
else: # Alors on a le nom de la chaine
self.isNomChaine = True
elif( name == "diffusion" ):
self.dateEpisode = attrs.get( "date", "" )
elif( name == "resume" ):
self.isResume = True
elif( name == "produit" ):
self.image = attrs.get( "sml_img_url", "" )
## Methode qui renvoie les donnees d'une balise
# @param data Donnees d'une balise
def characters( self, data ):
data = unicodedata.normalize( 'NFKD', data ).encode( 'ascii','ignore' )
if( self.isNomChaine ):
self.nomChaine = data
self.nomChaineConnu = True
self.isNomChaine = False
elif( self.isNomEmission ):
self.nomEmission = data
self.nomEmissionConnu = True
self.isNomEmission = False
elif( self.isNomEpisode ):
self.nomEpisode = data
self.nomEpisodeConnu = True
self.isNomEpisode = False
elif( self.isNomVideo ):
self.nomVideo = data
self.nomVideoConnu = True
self.isNomVideo = False
elif( self.isResume ):
self.resume = data
self.isResume = False
## Methode appelee lors de la fermeture d'une balise
# @param name Nom de la balise
def endElement( self, name ):
if( name == "categorie" ):
if( self.nomEmissionConnu ): # On a fini de traiter une emission
self.listeEmissions[ self.nomEmission.title() ] = self.listeVideos
self.listeVideos = []
self.nomEmissionConnu = False
else: # On a fini de traiter une chaine
self.listeFichiers[ self.nomChaine.title() ] = self.listeEmissions
self.listeEmissions = {}
self.nomChaineConnu = False
elif( name == "nom" ):
pass
elif( name == "diffusion" ):
self.listeVideos.append( [ self.nomEpisode.title(), self.dateEpisode, self.nomVideo, self.image, self.resume ] )
self.nomEpisodeConnu = False
self.nomVideoConnu = False
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import re
import os
from Fichier import Fichier
from Plugin import Plugin
##########
# Classe #
##########
class Gulli( Plugin ):
urlListeProgrammes = "http://replay.gulli.fr/"
listeEmissionsRegEx = re.compile( '<a href="([^<]+?)".*?alt="([^<]+?)"' )
lienVideoRegEx = re.compile( "URL_RTMP[^,]+?'([^,]+?)'," )
def __init__( self ):
Plugin.__init__( self, "Gulli", "http://www.gulli.fr", 1 )
# Liste des programmes sous la forme
# { Chaine : [ Nom, Lien ] }
self.listeProgrammes = {}
if os.path.exists( self.fichierCache ):
self.listeProgrammes = self.chargerCache()
def rafraichir( self ):
self.afficher( u"Récupération de la liste des émissions..." )
# On remet a 0 la liste des programmes
self.listeProgrammes.clear()
# On recupere la page qui contient toutes les informations
pageProgrammes = self.API.getPage( self.urlListeProgrammes )
# On decoupe la page selon les chaines ( Dessins Animes, ... )
resultats = re.split( "<h2>([^<]+)</h2>", pageProgrammes )[ 1 : ]
for ( chaine, texteChaine ) in ( zip( resultats[ 0::2 ], resultats[ 1::2 ] ) ):
# On ajoute la chaine
chaine = chaine.title()
self.listeProgrammes[ chaine ] = []
# On extrait les noms des programmes avec le lien vers la page qui contient la video
resultatsEmissions = re.findall( self.listeEmissionsRegEx, texteChaine )
for res in resultatsEmissions:
lienPage = self.url + res[ 0 ]
nom = res[ 1 ]
# On va recuperer la page qui contient le lien vers la video
pageVideo = self.API.getPage( lienPage )
# On en extrait le lien de la video
lienVideo = re.findall( self.lienVideoRegEx, pageVideo )[ 0 ]
# On l'ajoute a la liste
self.listeProgrammes[ chaine ].append( [ nom, lienVideo ] )
self.sauvegarderCache( self.listeProgrammes )
self.afficher( u"Liste sauvegardée" )
def listerChaines( self ):
for chaine in self.listeProgrammes.keys():
self.ajouterChaine( chaine )
def listerEmissions( self, chaine ):
self.chaineCourante = chaine
self.ajouterEmission( chaine, chaine )
def listerFichiers( self, emission ):
if( self.listeProgrammes.has_key( self.chaineCourante ) ):
for( nom, lien ) in self.listeProgrammes[ self.chaineCourante ]:
# On extrait l'extension du fichier
basename, extension = os.path.splitext( lien )
self.ajouterFichier( self.chaineCourante, Fichier( nom, "Inconnue", lien, nom + extension ) )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier LICENSE #
#########################################
#~ Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
#~ Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
#~ Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os
from Plugin import Plugin
from Fichier import Fichier
import re,unicodedata,datetime
##########
# Classe #
##########
class TF1( Plugin ):
"""Classe abstraite Plugin dont doit heriter chacun des plugins"""
videoBaseUrl = "http://videos.tf1.fr/"
listeEmissionBaseUrl = "http://videos.tf1.fr/videos-en-integralite/"
listeEmissionPage1Pattern = re.compile("<a onmousedown=\"[^\"]*integralite.([^']*?)@html[^>]*>De A à Z", re.DOTALL)
listeEmissionPagePattern = re.compile("<a href=\"/videos-en-integralite/([^\"]*.html)\" class=\"c2 t3\">", re.DOTALL)
emissionInfosPattern = re.compile("<a href=\"/([^/]+?)/.*?.html\" class=\"c2\"><strong class=\"t4\">([^<]+)</strong>", re.DOTALL)
infosFichierPattern = re.compile("<a href=\"/([^\"]*-\d+.html)\" class=\"t3\">([^<]*)</a></h4>", re.DOTALL)
listeEmissions = {}
listeFichiers = {}
def __init__( self):
Plugin.__init__( self, "TF1", "http://www.tf1.fr/")
def rafraichir( self ):
pass
def listerChaines( self ):
self.ajouterChaine("TF1")
def listerEmissions( self, chaine ):
match = re.search(self.listeEmissionPage1Pattern, self.API.getPage(self.listeEmissionBaseUrl))
if match == None:
return []
urls = [self.listeEmissionBaseUrl+match.group(1)+".html"]
for index in re.findall(self.listeEmissionPagePattern, self.API.getPage(urls[0])):
urls.append(self.listeEmissionBaseUrl+index)
for page in self.API.getPages(urls).values():
for emission in re.findall(self.emissionInfosPattern, page):
if not self.listeEmissions.has_key(emission[1]):
self.listeEmissions[emission[1]] = self.videoBaseUrl+emission[0]+"/"
liste = self.listeEmissions.keys()
liste.sort()
for emission in liste:
self.ajouterEmission(chaine, emission)
def listerFichiers( self, emission ):
if not self.listeEmissions.has_key(emission):
return
#~ print self.listeEmissions[emission]+"video-integrale/"
for fichier in re.findall( self.infosFichierPattern, self.API.getPage(self.listeEmissions[emission]+"video-integrale/")):
print fichier
return
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#~ import sys
#~ sys.path[ :0 ] = [ '../', '../lib/' ] # On ajoute des repertoires au path
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import re
import os
import os.path
#~ import pickle
import xml.sax
from Podcasts import PodcastsHandler
from Fichier import Fichier
from Plugin import Plugin
###########
# Classes #
###########
class FranceInter( Plugin ):
urlListesEmissions = [ [ "Du lundi au vendredi", "http://sites.radiofrance.fr/franceinter/pod/index.php?page=chrono&jd=sem" ],
[ "Le samedi", "http://sites.radiofrance.fr/franceinter/pod/index.php?page=chrono&jd=sam" ],
[ "Le dimanche", "http://sites.radiofrance.fr/franceinter/pod/index.php?page=chrono&jd=dim" ]
]
listeEmissions = {} # { Nom chaine : { Nom emission : URL fichier XML } }
urlPageDescriptive = "http://sites.radiofrance.fr/_c/php/popcast.php?chaine=1&cid="
pageDescriptiveRegEx = re.compile( '<h2>(.+?)</h2>.+?<p class="rssLink">(.+?)</p>' , re.DOTALL )
derniereChaine = ""
def __init__( self ):
Plugin.__init__( self, "France Inter", "http://sites.radiofrance.fr/franceinter/accueil/", 30 )
if os.path.exists( self.fichierCache ):
self.listeEmissions = self.chargerCache()
def rafraichir( self ):
self.afficher( u"Récupération de la liste des émissions..." )
# On remet a 0 la liste des emissions
self.listeEmissions.clear()
# Pour chaque page
for ( nom, urlPage ) in self.urlListesEmissions:
# On cree la chaine dans la liste des programmes
self.listeEmissions[ nom ] = {}
# On recupere la page web
page = self.API.getPage( urlPage )
# On extrait les numeros de chacune des pages des podcasts
listeNumeros = re.findall( '<h6><a href="javascript:popcast\(([0-9]+?), 1\);"', page )
# On cree la liste de toutes les pages que l'on doit recuperer
listeURL = []
for numero in listeNumeros:
listeURL.append( self.urlPageDescriptive + numero )
# On recupere toutes ces pages
listePages = self.API.getPages( listeURL )
# Pour chaque page = emission
for pageEmission in listePages.values():
# On recupere les informations
infos = re.findall( self.pageDescriptiveRegEx, pageEmission )
for ( nomEmission, urlFichierXML ) in infos:
nomEmission = nomEmission.replace( "»", "" ).title()
self.listeEmissions[ nom ][ nomEmission ] = urlFichierXML
self.sauvegarderCache( self.listeEmissions )
self.afficher( u"Liste des émissions sauvegardées" )
def listerChaines( self ):
for chaine in self.listeEmissions.keys():
self.ajouterChaine( chaine )
def listerEmissions( self, chaine ):
if( self.listeEmissions.has_key( chaine ) ):
self.derniereChaine = chaine
for emission in self.listeEmissions[ chaine ].keys():
self.ajouterEmission( chaine, emission )
def listerFichiers( self, emission ):
if( self.listeEmissions.has_key( self.derniereChaine ) ):
if( self.listeEmissions[ self.derniereChaine ].has_key( emission ) ):
# On recupere la page web qui liste les fichiers
pageXML = self.API.getPage( self.listeEmissions[ self.derniereChaine ][ emission ] )
# On extrait les fichiers
listeFichiers = []
handler = PodcastsHandler( listeFichiers )
try:
xml.sax.parseString( pageXML, handler )
except:
return
# On ajoute les fichiers
for fichier in listeFichiers:
self.ajouterFichier( emission, fichier )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import re
import os
from Fichier import Fichier
from Plugin import Plugin
##########
# Classe #
##########
class MediciTV( Plugin ):
# Liens
urlPageEmissions = "http://www.medici.tv/api/menu/playlist/"
urlPageFichiers = "http://www.medici.tv/api/playlist/_ID_/_PAGE_/"
urlPageFichiersLien = "http://www.medici.tv/api/_PATH_"
lienRTMPFichier = "rtmp://fms033.lo1.hwcdn.net/v4m4b2s4/_definst_/mp4:fms/_LIEN_?FLVPlaybackVersion=2.1&doppl=d4b9dc3598d53667&dopsig=400d0e45687214d4f95eaf4be6791054"
# RegEx
listeEmissionsRegEx = re.compile( "<id>([^<]+)</id>.*?<title>([^<]+)</title>", re.DOTALL )
listeFichiersRegEx = re.compile( "<path>([^<]+)</path>.*?<title>([^<]+)</title>.*?<line2>([^<]+)</line2>", re.DOTALL )
listeFichiersDernierePageRegEx = re.compile( "<last_page>\d</last_page>" )
listeFichiersNomFichierRegEx = re.compile( "<stream>([^<]+)</stream>" )
# Listes
listeEmissions = {} # Clef = nom emission, Valeur = id de l'emission
def __init__( self):
Plugin.__init__( self, "Medici TV", "http://www.medici.tv", 30 )
def rafraichir( self ):
pass
def listerChaines( self ):
self.ajouterChaine( self.nom )
def listerEmissions( self, chaine ):
# On recupere la page qui liste les emissions
pageEmissions = self.API.getPage( self.urlPageEmissions )
# On extrait les emissions
resultats = re.findall( self.listeEmissionsRegEx, pageEmissions )
for res in resultats:
idEmission = res[ 0 ]
nomEmission = res[ 1 ]
# On enregistre l'emission et son id
self.listeEmissions[ nomEmission ] = idEmission
# On ajoute l'emission
self.ajouterEmission( chaine, nomEmission )
def listerFichiers( self, emission ):
# On recupere l'id de l'emission dont on veut les fichiers
if( self.listeEmissions.has_key( emission ) ):
idEmission = self.listeEmissions[ emission ]
# On va commencer a la premier page qui liste les fichiers
urlPageCourante = self.urlPageFichiers.replace( "_ID_", idEmission ).replace( "_PAGE_", "0" )
dernierePage = self.extraireFichierPage( emission, urlPageCourante )
# On continue sur les autres pages s'il y en a
if( dernierePage != 1 ):
for page in range( 2, dernierePage + 1 ):
urlPageCourante = self.urlPageFichiers.replace( "_ID_", idEmission ).replace( "_PAGE_", str( page ) )
self.extraireFichierPage( emission, urlPageCourante )
def extraireFichierPage( self, emission, urlPageCourante ):
pageCourante = self.API.getPage( urlPageCourante )
# On extrait le numero de la derniere page
try :
dernierePage = int( re.findall( self.listeFichiersDernierePageRegEx )[ 0 ] )
except :
dernierePage = 1
# On extrait les fichiers
resultatsFichiers = re.findall( self.listeFichiersRegEx, pageCourante )
for resFichiers in resultatsFichiers:
pathFichier = resFichiers[ 0 ]
nomFichier = resFichiers[ 1 ]
try :
dateFichier = resFichiers[ 2 ].split( "-" )[ 1 ]
except :
dateFichier = "Inconnue"
# On doit maintenant recuperer le lien du fichier sur une autre page
urlPageLienFichier = self.urlPageFichiersLien.replace( "_PATH_", pathFichier )
pageLienFichier = self.API.getPage( urlPageLienFichier )
if( pageLienFichier.find( "Please come back later" ) != -1 ): # S'il y a une erreur sur la page
continue
lienFichier = re.findall( self.listeFichiersNomFichierRegEx, pageLienFichier )[ 0 ]
lienBonFormat = self.lienRTMPFichier.replace( "_LIEN_", str( lienFichier.split( "/" )[ -1 ] ) )
# On ajoute le fichier
self.ajouterFichier( emission, Fichier( nomFichier, dateFichier, lienBonFormat ) )
# On renvoit le numero de la derniere page
return dernierePage
#~ rtmp://fms033.lo1.hwcdn.net/v4m4b2s4/_definst_/mp4:fms/VERBIER-1-20100716-combins-medici-hi.mp4?FLVPlaybackVersion=2.1&doppl=d4b9dc3598d53667&dopsig=400d0e45687214d4f95eaf4be6791054
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
# Modules Python
import datetime
import os.path
import re
import xml.sax
from xml.sax.handler import ContentHandler
# Modules de TVD
from Fichier import Fichier
from Plugin import Plugin
# Logger de TVD
import logging
logger = logging.getLogger( __name__ )
###########
# Classes #
###########
class CanalPlus( Plugin ):
urlFichierXMLListeProgrammes = "http://www.canalplus.fr/rest/bootstrap.php?/bigplayer/initPlayer"
urlFichierXMLEmissions = "http://www.canalplus.fr/rest/bootstrap.php?/bigplayer/getMEAs/"
urlFichierXMLFichiers = "http://www.canalplus.fr/rest/bootstrap.php?/bigplayer/getVideos/"
def __init__( self ):
Plugin.__init__( self, "Canal+", "http://www.canalplus.fr/", 7 )
self.listeProgrammes = {} # { Nom chaine : { Nom emission : ID emission } }
self.derniereChaine = ""
if os.path.exists( self.fichierCache ):
self.listeProgrammes = self.chargerCache()
def rafraichir( self ):
logger.info( "récupération de la liste des chaines et des émissions" )
# On remet a 0 la liste des programmes
self.listeProgrammes.clear()
# On recupere la page qui contient les infos
pageXML = self.API.getPage( self.urlFichierXMLListeProgrammes )
# Handler
handler = CanalPlusListeProgrammesHandler( self.listeProgrammes )
# On parse le fichier xml
try:
xml.sax.parseString( pageXML, handler )
except:
logger.error( "impossible de parser le fichier XML de la liste des programmes" )
return
# On sauvegarde la liste dans le cache
self.sauvegarderCache( self.listeProgrammes )
logger.info( "liste des programmes sauvegardée" )
def listerChaines( self ):
for chaine in self.listeProgrammes.keys():
self.ajouterChaine( chaine )
def listerEmissions( self, chaine ):
if( self.listeProgrammes.has_key( chaine ) ):
self.derniereChaine = chaine
for emission in self.listeProgrammes[ chaine ].keys():
self.ajouterEmission( chaine, emission )
def listerFichiers( self, emission ):
if( self.listeProgrammes.has_key( self.derniereChaine ) ):
listeEmissions = self.listeProgrammes[ self.derniereChaine ]
if( listeEmissions.has_key( emission ) ):
IDEmission = listeEmissions[ emission ]
# On recupere la page qui contient les ids des fichiers
pageXML = self.API.getPage( self.urlFichierXMLEmissions + IDEmission )
# On extrait les ids
listeIDs = re.findall( "<ID>(.+?)</ID>", pageXML )
# On construit la liste des liens a recuperer
listeURL = []
for IDFichier in listeIDs:
listeURL.append( self.urlFichierXMLFichiers + IDFichier )
# On recupere les pages correspondantes
pagesXML = self.API.getPages( listeURL )
# On parse chacune de ces pages
for URL in listeURL:
pageXMLFichier = pagesXML[ URL ]
# Handler
infosFichier = []
handler = CanalPlusListeFichierHandler( infosFichier )
# On parse le fichier xml
try:
xml.sax.parseString( pageXMLFichier, handler )
except:
logger.error( "impossible de parser le fichier XML de la liste des fichiers" )
continue
# On ajoute le fichier
nom, date, lienLD, lienMD, lienHD, urlImage, descriptif = infosFichier
# On transforme la date en type datetime.date
try:
dateDecoupee = map( int, date.split( "/" ) )
dateBonFormat = datetime.date( dateDecoupee[ 2 ], dateDecoupee[ 1 ], dateDecoupee[ 0 ] )
except:
dateBonFormat = date
if( lienHD != "" and lienHD[ : 4 ] == "rtmp" ):
# On extrait l'extension du fichier
basename, extension = os.path.splitext( lienHD )
self.ajouterFichier( emission, Fichier( "[HD]" + nom, dateBonFormat, lienHD, nom + extension, urlImage, descriptif ) )
elif( lienMD != "" and lienMD[ : 4 ] == "rtmp" ):
# On extrait l'extension du fichier
basename, extension = os.path.splitext( lienMD )
self.ajouterFichier( emission, Fichier( "[MD]" + nom, dateBonFormat, lienMD, nom + extension, urlImage, descriptif ) )
elif( lienLD != "" and lienLD[ : 4 ] == "rtmp" ):
# On extrait l'extension du fichier
basename, extension = os.path.splitext( lienLD )
self.ajouterFichier( emission, Fichier( "[LD]" + nom, dateBonFormat, lienLD, nom + extension, urlImage, descriptif ) )
#
# Parsers XML pour Canal+
#
## Classe qui permet de lire le fichier XML de Canal qui liste les emissions
class CanalPlusListeProgrammesHandler( ContentHandler ):
# Constructeur
# @param listeProgrammes Liste des programmes que le parser va remplir
def __init__( self, listeProgrammes ):
# Liste des programmes
self.listeProgrammes = listeProgrammes
# Liste des emissions d'un programme (temporaire)
# Clef : nom emission, Valeur : ID
self.listeEmissions = {}
# Initialisation des variables a Faux
self.nomChaineConnu = False
self.isNomChaine = False
self.isIDEmission = False
self.nomEmissionConnu = False
self.isNomEmission = False
## Methode appelee lors de l'ouverture d'une balise
# @param name Nom de la balise
# @param attrs Attributs de cette balise
def startElement( self, name, attrs ):
if( name == "THEMATIQUE" ):
pass
elif( name == "NOM" and self.nomChaineConnu == False ):
self.isNomChaine = True
elif( name == "ID" and self.nomChaineConnu == True ):
self.isIDEmission = True
elif( name == "NOM" and self.nomChaineConnu == True ):
self.isNomEmission = True
## Methode qui renvoie les donnees d'une balise
# @param data Donnees d'une balise
def characters( self, data ):
if( self.isNomChaine ):
self.nomChaine = data
self.nomChaineConnu = True
self.isNomChaine = False
elif( self.isIDEmission ):
self.IDEmission = data
self.isIDEmission = False
elif( self.isNomEmission ):
self.nomEmission = data
self.nomEmissionConnu = True
self.isNomEmission = False
## Methode appelee lors de la fermeture d'une balise
# @param name Nom de la balise
def endElement( self, name ):
if( name == "THEMATIQUE" ):
self.listeProgrammes[ self.nomChaine.title() ] = self.listeEmissions
self.listeEmissions = {}
self.nomChaineConnu = False
elif( name == "NOM" and self.nomEmissionConnu ):
self.listeEmissions[ self.nomEmission.title() ] = self.IDEmission
self.nomEmissionConnu = False
## Classe qui permet de lire le fichier XML d'un fichier de Canal
class CanalPlusListeFichierHandler( ContentHandler ):
# Constructeur
# @param infosFichier Infos du fichier que le parser va remplir
def __init__( self, infosFichier ):
# Liste des programmes
self.infosFichier = infosFichier
# On n'a pas forcement les 3 liens
self.lienLD = ""
self.lienMD = ""
self.lienHD = ""
# Initialisation des variables a Faux
self.isTitre = False
self.isDate = False
self.isLienLD = False
self.isLienMD = False
self.isLienHD = False
self.isLienImage = False
self.isDescriptif = False
## Methode appelee lors de l'ouverture d'une balise
# @param name Nom de la balise
# @param attrs Attributs de cette balise
def startElement( self, name, attrs ):
if( name == "DESCRIPTION" ):
self.descriptif = ""
self.isDescriptif = True
elif( name == "DATE" ):
self.isDate = True
elif( name == "TITRAGE" ):
self.titre = ""
elif( name == "TITRE" or name == "SOUS_TITRE" ):
self.isTitre = True
elif( name == "PETIT" ):
self.isLienImage = True
elif( name == "BAS_DEBIT" ):
self.isLienLD = True
elif( name == "HAUT_DEBIT" ):
self.isLienMD = True
elif( name == "HD" ):
self.isLienHD = True
## Methode qui renvoie les donnees d'une balise
# @param data Donnees d'une balise
def characters( self, data ):
if( self.isDescriptif ):
self.descriptif += data
elif( self.isDate ):
self.date = data
self.isDate = False
elif( self.isTitre ):
self.titre += " %s" %( data )
self.isTitre = False
elif( self.isLienImage ):
self.urlImage = data
self.isLienImage = False
elif( self.isLienLD ):
self.lienLD = data
self.isLienLD = False
elif( self.isLienHD ):
self.lienHD = data
self.isLienHD = False
## Methode appelee lors de la fermeture d'une balise
# @param name Nom de la balise
def endElement( self, name ):
if( name == "DESCRIPTION" ):
self.isDescriptif = False
elif( name == "VIDEO" ):
self.infosFichier[:] = self.titre, self.date, self.lienLD, self.lienMD, self.lienHD, self.urlImage, self.descriptif
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import hashlib
import os
import os.path
import xml.sax
from xml.sax.handler import ContentHandler
from Navigateur import Navigateur
import logging
logger = logging.getLogger( __name__ )
#############
# Variables #
#############
# Repertoires qui contiennent des plugins
repPlugins = [ os.path.expanduser( "~" ) + "/.tvdownloader/plugins",
"plugins" ]
##########
# Classe #
##########
## Classe qui gere les plugins
class UpdateManager( object ):
# Liste des sites qui disposent des mises a jour
listeSites = [ "http://tvdownloader.googlecode.com/hg/plugins" ]
# Instance de la classe (singleton)
instance = None
## Surcharge de la methode de construction standard (pour mettre en place le singleton)
def __new__( self, *args, **kwargs ):
if( self.instance is None ):
self.instance = super( UpdateManager, self ).__new__( self )
return self.instance
## Constructeur
def __init__( self ):
self.navigateur = Navigateur()
## Methode pour generer le fichier XML de description des plugins
@staticmethod
def creerXML():
# On ouvre le fichier XML
try:
fichierXML = open( "versionsPlugins.xml", "wt" )
except:
logger.error( "impossible d'ouvrir le fichier XML en ecriture" )
return
fichierXML.write( '<?xml version="1.0" encoding="UTF-8"?>\n' )
fichierXML.write( "<plugins>\n" )
# Pour chaque fichier de plugin
for fichier in os.listdir( "plugins" ):
# Tous les fichiers .py autre que __init__.py sont des plugins
if( fichier [ -3 : ] == ".py" and fichier.find( "__init__.py" ) == -1 ):
fichierCheminComplet = "plugins/%s" %( fichier )
# Nom du fichier
nom = fichier
# Date de la derniere modification
date = os.stat( fichierCheminComplet ).st_mtime
# Somme de controle SHA1
fichierPlugin = open( fichierCheminComplet, "rt" )
sha1 = hashlib.sha1( fichierPlugin.read() ).hexdigest()
fichierPlugin.close()
# On ajoute l'element au fichier XML
fichierXML.write( '\t<plugin nom="%s" dateModification="%s" sha1="%s"></plugin>\n' %( nom, date, sha1 ) )
# On ferme le fichier XML
fichierXML.write( "</plugins>\n" )
fichierXML.close()
## Methode qui verifie si les plugins disposent d'une mise a jour
# @param site Sites sur lesquel aller chercher la mise a jour
# @return Liste des plugins a mettre a jour [ Nom du plugin, URL ou charger le plugin, SHA1 du plugin ]
def verifierMiseAjour( self, site ):
listePluginsXML = [] # [ Nom, date derniere modification, SHA1 ]
listePluginAMettreAJour = [] # [ Nom du plugin, URL ou charger le plugin, SHA1 du plugin ]
handler = UpdateManagerHandler( listePluginsXML )
# On recupere le fichier XML de description des plugins
fichierXML = self.navigateur.getPage( "%s/versionsPlugins.xml" %( site ) )
if( fichierXML == "" ): # Si on n'a rien recupere, on essaye un autre site
logger.warn( "aucune information disponible sur le site %s" %( site ) )
return []
# On vide la liste
del listePluginsXML[ : ]
# On parse le fichier XML
try:
xml.sax.parseString( fichierXML, handler )
except:
logger.error( "impossible de parser le fichier XML du site %s" %( site ) )
return []
# Pour chaque plugin decrit dans le fichier XML
for( nom, dateModification, sha1 ) in listePluginsXML:
# On n'a pas une nouvelle version du plugin
nouvelleVersion = False
# Dans chacun des repertoires qui contiennent des plugins
for rep in repPlugins:
pluginCheminComplet = "%s/%s" %( rep, nom )
# Si le plugin est present
if( os.path.isfile( pluginCheminComplet ) ):
# Si la version dont l'on dispose est moins recente que celle du site
if( os.stat( pluginCheminComplet ).st_mtime < dateModification ):
nouvelleVersion = True
else:
nouvelleVersion = False
break # On peut arrete de chercher, on a deja le plus recent
# S'il y a une nouvelle version
if( nouvelleVersion ):
listePluginAMettreAJour.append( [ nom, "%s/%s" %( site, nom ), sha1 ] )
# On a fini de lire les infos sur ce site, pas besoin de parcourir les autres
return listePluginAMettreAJour
# Methode pour installer la mise a jour d'un plugin
# @param nomPlugin Nom du fichier du plugin a mettre a jour
# @param urlPlugin URL ou charger le plugin
# @param sha1 Somme de controle SHA1 du plugin
# @return Si le plugin a ete correctement installe
def mettreAJourPlugin( self, nomPlugin, urlPlugin, sha1 ):
logger.info( "mise a jour du plugin %s" %( nomPlugin ) )
# On telecharge le plugin
codePlugin = self.navigateur.getPage( urlPlugin )
if( codePlugin == "" ):
return False
# On verifie la somme de controle du plugin
if( hashlib.sha1( codePlugin ).hexdigest() != sha1 ):
logger.warn( "somme de controle incorrecte pour le fichier %s" %( urlPlugin ) )
return False
# On met en place le plugin
fichier = open( "%s/%s" %( repPlugins[ 0 ], nomPlugin ), 'wt' )
fichier.write( codePlugin )
fichier.close()
return True
#
# Parser XML pour le fichier versionsPlugins.xml
#
## Classe qui permet de lire le fichier XML versionsPlugins.xml
class UpdateManagerHandler( ContentHandler ):
# Constructeur
# @param listePluginsXML Liste des plugins que l'on va remplir
def __init__( self, listePluginsXML ):
self.listePluginsXML = listePluginsXML # [ Nom, date derniere modification, SHA1 ]
## Methode appelee lors de l'ouverture d'une balise
# @param name Nom de la balise
# @param attrs Attributs de cette balise
def startElement( self, name, attrs ):
if( name == "plugin" ):
nom = attrs.get( "nom", "" )
dateModification = attrs.get( "dateModification", "" )
sha1 = attrs.get( "sha1", "" )
self.listePluginsXML.append( [ nom, float( dateModification ), sha1 ] )
## Methode qui renvoie les donnees d'une balise
# @param data Donnees d'une balise
def characters( self, data ):
pass
## Methode appelee lors de la fermeture d'une balise
# @param name Nom de la balise
def endElement( self, name ):
pass
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier LICENSE #
#########################################
#~ Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
#~ Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
#~ Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import httplib,re,zlib, os.path, time, pickle
from random import choice
from traceback import print_exc
import logging
logger = logging.getLogger( __name__ )
from htmlentitydefs import codepoint2name
SPECCAR_CODE = {}
type = []
for code in codepoint2name:
SPECCAR_CODE[codepoint2name[code]] = unicode(unichr(code)).encode("UTF-8", "replace")
from Fichier import Fichier
from Option import Option
##########
# Classe #
##########
class APIPrive():
## Contructeur
# @param self l'objet courant
def __init__(self):
self.listePluginActif = {}
self.listePlugin = {}
## Active un plugin (il faut qu'il ait déjà été ajouté).
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @return Rien
def activerPlugin(self, nomPlugin):
if self.listePlugin.has_key(nomPlugin):
self.listePluginActif[nomPlugin] = self.listePlugin[nomPlugin]
## Désactive un plugin (il faut qu'il ait déjà été ajouté).
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @return Rien
def desactiverPlugin(self, nomPlugin):
if self.listePluginActif.has_key(nomPlugin):
self.listePluginActif.pop(nomPlugin)
## Ajoute un plugin.
# @param self l'objet courant
# @param instance l'instance du plugin
# @return Rien
def ajouterPlugin(self, instance):
if not self.listePlugin.has_key(instance.nom):
self.listePluginActif[instance.nom] = instance
self.listePlugin[instance.nom] = instance
## Spécifie la liste des instances des plugins.
# @param self l'objet courant
# @param liste la liste des instances
# @return Rien
# @deprecated Utiliser #ajouterPlugin à la place.
def setListeInstance(self, liste):
logger.warn("DEPRECATED: APIPrive.setListeInstance: utilisez #ajouterPlugin")
self.listePluginActif = {}
for instance in liste:
self.ajouterPlugin(instance)
#/*******************
# * CONSTANTES *
# *******************/
DATA_CHAINE = "chaines"
DATA_EMISSION = "emissions"
DATA_FICHIER = "fichiers"
#/**************
# * GETTERS *
# **************/
## Renvoie la liste des plugins (leur nom)
# @param self l'objet courant
# @return la liste des noms des plugins
def getPluginListe(self):
return self.listePluginActif.keys()
## Renvoie la liste des chaînes.
#
# Si nomPlugin est égal à None, la liste des chaînes de tout les plugins est renvoyée, sinon c'est celle du plugin portant le nom passé en paramètre.
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @return la liste des chaînes du plugin
def getPluginListeChaines(self, nomPlugin=None):
if nomPlugin != None and not self.listePluginActif.has_key(nomPlugin):
return []
liste = []
if nomPlugin == None:
for nom in self.listePluginActif.keys():
plugin = self.listePluginActif[nom]
if len(plugin.pluginDatas[APIPrive.DATA_CHAINE]) == 0:
plugin.listerChaines()
liste+=plugin.pluginDatas[APIPrive.DATA_CHAINE]
else:
plugin = self.listePluginActif[nomPlugin]
if len(plugin.pluginDatas[APIPrive.DATA_CHAINE]) == 0:
plugin.listerChaines()
liste+=plugin.pluginDatas[APIPrive.DATA_CHAINE]
return liste
## Renvoie la liste des émissions pour un plugin et une chaîne donné.
#
# Si nomPlugin est égal à None, la liste des émissions de tout les plugins est renvoyée, sinon c'est celle du plugin portant le nom passé en paramètre. Si chaine est égal à None, la liste des émissions de toute les chaines du plugin est renvoyée.
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @param chaine le nom de la chaîne
# @return la liste des émissions
def getPluginListeEmissions(self, nomPlugin=None, chaine=None):
if nomPlugin != None and not self.listePluginActif.has_key(nomPlugin):
return []
liste= []
if nomPlugin == None:
for nom in self.listePluginActif.keys():
plugin = self.listePluginActif[nom]
for chaine in self.getPluginListeChaines(nom):
if not plugin.pluginDatas[APIPrive.DATA_EMISSION].has_key(chaine):
plugin.pluginDatas[APIPrive.DATA_EMISSION][chaine] = []
plugin.listerEmissions(chaine)
liste+=plugin.pluginDatas[APIPrive.DATA_EMISSION][chaine]
elif chaine == None:
plugin = self.listePluginActif[nomPlugin]
for chaine in self.getPluginListeChaines(nomPlugin):
if not plugin.pluginDatas[APIPrive.DATA_EMISSION].has_key(chaine):
plugin.pluginDatas[APIPrive.DATA_EMISSION][chaine] = []
plugin.listerEmissions(chaine)
liste+=plugin.pluginDatas[APIPrive.DATA_EMISSION][chaine]
else:
plugin = self.listePluginActif[nomPlugin]
if not plugin.pluginDatas[APIPrive.DATA_EMISSION].has_key(chaine):
plugin.pluginDatas[APIPrive.DATA_EMISSION][chaine] = []
plugin.listerEmissions(chaine)
liste+=plugin.pluginDatas[APIPrive.DATA_EMISSION][chaine]
return liste
## Renvoie la liste des fichiers pour un plugin et une émission donné
#
# Si nomPlugin est égal à None, la liste des fichiers de tout les plugins est renvoyée, sinon c'est celle du plugin portant le nom passé en paramètre. Si emission est égal à None, la liste des fichiers de toute les émissions du plugin est renvoyée.
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @param emission le nom de l'émission
# @return la liste des fichiers
def getPluginListeFichiers(self, nomPlugin=None, emission=None):
if nomPlugin != None and not self.listePluginActif.has_key(nomPlugin):
return []
liste= []
if nomPlugin == None:
for nom in self.listePluginActif.keys():
plugin = self.listePluginActif[nom]
for emission in self.getPluginListeEmissions(nom):
if not plugin.pluginDatas[APIPrive.DATA_FICHIER].has_key(emission):
plugin.pluginDatas[APIPrive.DATA_FICHIER][emission] = []
plugin.listerFichiers(emission)
liste+=plugin.pluginDatas[APIPrive.DATA_FICHIER][emission]
elif emission == None:
plugin = self.listePluginActif[nomPlugin]
for emission in self.getPluginListeEmissions(nomPlugin):
if not plugin.pluginDatas[APIPrive.DATA_FICHIER].has_key(emission):
plugin.pluginDatas[APIPrive.DATA_FICHIER][emission] = []
plugin.listerFichiers(emission)
liste+=plugin.pluginDatas[APIPrive.DATA_FICHIER][emission]
else:
plugin = self.listePluginActif[nomPlugin]
if not plugin.pluginDatas[APIPrive.DATA_FICHIER].has_key(emission):
plugin.pluginDatas[APIPrive.DATA_FICHIER][emission] = []
plugin.listerFichiers(emission)
liste+=plugin.pluginDatas[APIPrive.DATA_FICHIER][emission]
return liste
## Renvoie la liste des options pour un plugin donné
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @return la liste des options
def getPluginListeOptions(self, nomPlugin):
if not self.listePluginActif.has_key(nomPlugin):
return []
return self.listePluginActif[nomPlugin].pluginOptions
## Renvoie l'option d'un plugin
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @param nomOption le nom de l'option
# @return la valeur de l'option, None en cas d'échec
def getPluginOption(self, nomPlugin, nomOption):
if nomPlugin != None and not self.listePluginActif.has_key(nomPlugin):
return None
plugin = self.listePluginActif[nomPlugin]
for option in plugin.pluginOptions:
if option.getNom() == nomOption:
return option
return None
#/**************
# * SETTERS *
# **************/
## Change la valeur d'une option d'un plugin.
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @param valeur la valeur de l'option
# @return Rien
def setPluginOption(self, nomPlugin, nomOption, valeur):
if nomPlugin != None and not self.listePluginActif.has_key(nomPlugin):
return None
plugin = self.listePluginActif[nomPlugin]
plugin.pluginDatas = {"chaines":[],
"emissions":{},
"fichiers":{}}
for option in plugin.pluginOptions:
if option.getNom() == nomOption:
option.setValeur(valeur)
#/************
# * DIVERS *
# ************/
## Rafraichie un plugin (appel à Plugin.rafraichir)
# @param self l'objet courant
# @param nomPlugin le nom du plugin
# @return Rien
def pluginRafraichir(self, nomPlugin):
try:
if self.listePluginActif.has_key(nomPlugin):
self.listePluginActif[nomPlugin].vider()
self.listePluginActif[nomPlugin].rafraichir()
except Exception, ex:
logger.error("Erreur lors du rafraichissement du plugin",self.listePlugin[nomPlugin].nom+":"+str(ex))
print_exc()
## Rafraichie tous les plugins qui ont besoin de l'être.
#
# Doit être appelé obligatoirement après l'ajout des plugins.
# @param self l'objet courant
# @return Rien
def pluginRafraichirAuto(self):
t = time.time()
for instance in self.listePlugin.values():
if instance.frequence >= 0:
if os.path.isfile(instance.fichierCache):
delta = t-os.path.getmtime(instance.fichierCache)
if delta > instance.frequence*86400:
self.pluginRafraichir(instance.nom)
else:
self.pluginRafraichir(instance.nom)
#~ instance.chargerPreference()
#~ if len(instance.pluginOptions) == 0:
#~ instance.listerOptions()
instance.listerOptions()
if os.path.exists(instance.fichierConfiguration):
try:
file = open(instance.fichierConfiguration, "r")
tmp = pickle.load(file)
file.close()
for k in tmp.keys():
self.setPluginOption(instance.nom, k, tmp[k])
except:
logger.error( u"impossible de charger les préférences de %s" %( instance.nom ) )
## Effectue les tâches de sauvegarde avant la fermeture.
#
# Doit être absolument appelé avant la fermeture.
# @param self l'objet courant
def fermeture(self):
for instance in self.listePluginActif.values():
if len(instance.pluginOptions) > 0:
try:
pref = {}
for o in instance.pluginOptions:
pref[o.getNom()] = o.getValeur()
file = open(instance.fichierConfiguration, "w")
pickle.dump(pref, file)
file.close()
except:
logger.error("Erreur de sauvegarde des préférences de"+instance.nom)
#/*************
# * AUTRES *
# *************/
USER_AGENT = [ 'Mozilla/5.0 (Windows; U; Windows NT 5.1; fr; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1',
'Mozilla/5.0 (Windows; U; Windows NT 6.0; fr; rv:1.9.0.1) Gecko/2008070208 Firefox/3.0.1',
'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; fr; rv:1.9.0.3) Gecko/2008092414 Firefox/3.0.3',
'Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.0.6) Gecko/2009011913 Firefox/3.0.6',
'Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.1b2) Gecko/20081201 Firefox/3.1b2',
'Mozilla/5.0 (X11; U; Linux i686; fr; rv:1.9.1.1) Gecko/20090715 Firefox/3.5.1',
'Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.2) Gecko/20100115 Firefox/3.6',
'Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13',
'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)',
'Mozilla/5.0 (X11; U; Linux x86_64; en-us) AppleWebKit/528.5+ (KHTML, like Gecko, Safari/528.5+) midori',
'Opera/8.50 (Windows NT 5.1; U; en)',
'Opera/9.80 (X11; Linux x86_64; U; fr) Presto/2.2.15 Version/10.00',
'Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en-us) AppleWebKit/312.1 (KHTML, like Gecko) Safari/312' ]
PATTERN_CHARSET = re.compile("charset=(.*?)$", re.IGNORECASE)
PATTERN_SPECCAR= re.compile("&(.+?);")
PATTERN_URL = re.compile("http://(.+?)(/.*)|(.+?)(/.*)")
TAILLE_BLOCK = 1000#essayé avec 8k mais plante :/
HTTP_TIMEOUT = 5
def reponseHttpToUTF8(self, reponse):
"""Renvoie le corp d'une réponse HTTP en UTF8, décompressé et débarassé des caractères spéciaux html.
Renvoie la chaîne vide en cas d'échec."""
data = ""
if reponse.getheader('Content-Encoding', '').find('gzip') >= 0:
try:
decomp = zlib.decompressobj(16+zlib.MAX_WBITS)#chiffre "magic" apparemment
while True:
buff = reponse.read(APIPrive.TAILLE_BLOCK)
if not(buff):
break
data = data+decomp.decompress(buff)
except:
logger.warn("APIPrive.reponseHttpToUTF8(): erreur de décompression")
return ""
else:
data = reponse.read()
#Vérification de l'encodage et conversion si néscessaire
encoding = reponse.getheader("Content-Type", "")
if encoding != "":
try:
match = re.search(APIPrive.PATTERN_CHARSET, encoding)
if match != None and encoding != "utf-8":
data = unicode(data, match.group(1), "replace").encode("utf-8", "replace")
else:
logger.info("APIPrive.reponseHttpToUTF8(): encodage inconnu.")
except:
logger.error("APIPrive.reponseHttpToUTF8(): erreur de décodage.")
iters = []
for match in re.finditer(APIPrive.PATTERN_SPECCAR, data):
iters.insert(0, match)
for match in iters:
if match.group(1)[0] == "#":
try:
car = chr(int(match.group(1)[1:]))
data = data[:match.start()] + car + data[match.end():]
except:
#Rien
rien = None
elif SPECCAR_CODE.has_key(match.group(1)):
data = data[:match.start()] + SPECCAR_CODE[match.group(1)] + data[match.end():]
return data
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import threading
from PyQt4 import QtGui, QtCore
from GUI.Qt.MyQTableWidget import MyQTableWidget
from GUI.Qt.MyQPushButton import MyQPushButton
from UpdateManager import UpdateManager
from GUI.ConvertQString import *
##########
# Classe #
##########
## Classe qui gere le dialog du gestionnaire de mise a jour
class UpdateManagerDialog( QtGui.QDialog ):
## Constructeur
def __init__( self, parent ):
# Appel au constructeur de la classe mere
QtGui.QDialog.__init__( self, parent )
self.updateManager = UpdateManager()
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle( u"Mise à jour des plugins" )
# Dimensions la fenetre
self.resize( 1, 190 )
# Mise en place de son icone
self.setWindowIcon( QtGui.QIcon( "ico/gtk-refresh.svg" ) )
###
# Mise en place des widgets dans la fenetre
###
# Layout de grille principal
self.gridLayout = QtGui.QGridLayout( self )
# Font pour les titres
fontTitres = QtGui.QFont()
fontTitres.setPointSize( 11 )
fontTitres.setWeight( 75 )
fontTitres.setBold( True )
#
# Choix du miroir pour la mise a jour
#
# Label
self.labelMiroir = QtGui.QLabel( self )
self.labelMiroir.setFont( fontTitres )
self.labelMiroir.setText( u"Miroir :" )
# Choix du miroir
self.comboBoxMiroir = QtGui.QComboBox( self )
self.comboBoxMiroir.setEditable( True )
for miroir in UpdateManager.listeSites:
self.comboBoxMiroir.addItem( stringToQstring( miroir ) )
# Bouton pour lancer la recherche
self.pushButtonRecherche = QtGui.QPushButton( self )
self.pushButtonRecherche.setIcon( QtGui.QIcon( "ico/gtk-refresh.svg" ) )
self.pushButtonRecherche.setToolTip( u"Rechercher les mises à jour des plugins" )
# Label info
self.labelInfo = QtGui.QLabel( self )
self.labelInfo.setText( u"(il faut redémarer le logiciel pour que les mises à jour soient prises en compte)" )
#
# Affichage des plugins a mettre a jour
#
# Table widget qui contient la liste des plugins a mettre a jour
self.tableWidgetPlugins = MyQTableWidget( self )
# Il a 2 colonnes et 0 ligne (pour l'instant)
self.tableWidgetPlugins.setColumnCount( 2 )
self.tableWidgetPlugins.setRowCount( 0 )
# On ajoute les titres
self.tableWidgetPlugins.setHorizontalHeaderItem( 0,
self.tableWidgetPlugins.creerItem( "" ) )
self.tableWidgetPlugins.setHorizontalHeaderItem( 1,
self.tableWidgetPlugins.creerItem( "Nom du plugin" ) )
# Icones du tableWidget
self.iconeMAJ = QtGui.QIcon( "ico/gtk-add.svg" )
self.iconeMAJReussie = QtGui.QIcon( "ico/gtk-apply.svg" )
self.iconeMAJEchouee = QtGui.QIcon( "ico/gtk-cancel.svg" )
# Bouton pour lancer l'installation des plugins a mettre a jour
self.pushButtonLancerInstallation = MyQPushButton( self )
self.pushButtonLancerInstallation.setIcon( QtGui.QIcon( "ico/gtk-media-play-ltr.svg" ) )
self.pushButtonLancerInstallation.setToolTip( u"Installer les mises à jour des plugins" )
# Bouton pour redemarrer/fermer la fenetre
self.buttonBox = QtGui.QDialogButtonBox( self )
#~ self.buttonBox.addButton( "Redemmarer programme", QtGui.QDialogButtonBox.AcceptRole )
self.buttonBox.addButton( "Fermer", QtGui.QDialogButtonBox.RejectRole )
# On ajoute le tout au layout
self.gridLayout.addWidget( self.labelMiroir, 0, 0, 1, 1 )
self.gridLayout.addWidget( self.comboBoxMiroir, 0, 1, 1, 1 )
self.gridLayout.addWidget( self.pushButtonRecherche, 0, 2, 1, 1 )
self.gridLayout.addWidget( self.labelInfo, 1, 0, 1, 3 )
self.gridLayout.addWidget( self.tableWidgetPlugins, 2, 0, 1, 2 )
self.gridLayout.addWidget( self.pushButtonLancerInstallation, 2, 2, 1, 1 )
self.gridLayout.addWidget( self.buttonBox, 3, 0, 1, 3 )
###
# Signaux
###
QtCore.QObject.connect( self.pushButtonRecherche, QtCore.SIGNAL( "clicked()" ), self.rechercheMiseAJour )
QtCore.QObject.connect( self.pushButtonLancerInstallation, QtCore.SIGNAL( "clicked()" ), self.mettreAJourPlugins )
#~ QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "accepted()" ), self.??? )
QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "rejected()" ), self.reject )
QtCore.QObject.connect( self, QtCore.SIGNAL( "finRechercheMAJ(PyQt_PyObject)" ), self.afficherMiseAJour )
self.listePluginAMettreAJour = []
## Methode pour afficher la fenetre des preferences
def afficher( self ):
# On n'active pas le bouton d'installation
self.pushButtonLancerInstallation.setEnabled( False )
# On affiche la fenetre
self.exec_()
## Methode qui va lancer la recherche de mise a jour sur le site actuellement selectionne
def rechercheMiseAJour( self ):
def threadRechercheMiseAJour( self, site ):
listePluginAMettreAJour = self.updateManager.verifierMiseAjour( site )
self.emit( QtCore.SIGNAL( "finRechercheMAJ(PyQt_PyObject)" ), listePluginAMettreAJour )
site = qstringToString( self.comboBoxMiroir.currentText() )
threading.Thread( target = threadRechercheMiseAJour, args = ( self, site ) ).start()
## Methode qui affiche les mise a jour
# @param listePluginAMettreAJour Liste des plugins a mettre a jour [ Nom du plugin, URL ou charger le plugin, SHA1 du plugin ]
def afficherMiseAJour( self, listePluginAMettreAJour ):
self.listePluginAMettreAJour = listePluginAMettreAJour
self.tableWidgetPlugins.toutSupprimer()
# Si on n'a rien recuperer
if( len( listePluginAMettreAJour ) == 0 ):
QtGui.QMessageBox.information( self,
u"Mise à jour des plugins",
u"Aucune mise à jour disponible."
)
# On n'active pas le bouton d'installation
self.pushButtonLancerInstallation.setEnabled( False )
else:
ligneCourante = 0
for( nom, url, sha1 ) in self.listePluginAMettreAJour:
# On ajoute une ligne
self.tableWidgetPlugins.insertRow( ligneCourante )
self.tableWidgetPlugins.setLigne( ligneCourante, [ self.tableWidgetPlugins.creerItem( "" ),
self.tableWidgetPlugins.creerItem( stringToQstring( nom ) )
]
)
self.tableWidgetPlugins.item( ligneCourante, 0 ).setIcon( self.iconeMAJ )
ligneCourante += 1
# On active le bouton d'installation
self.pushButtonLancerInstallation.setEnabled( True )
## Methode qui met a jour tous les plugins
def mettreAJourPlugins( self ):
def threadMettreAJour( self ):
ligne = 0
for( nom, url, sha1 ) in self.listePluginAMettreAJour:
retour = self.updateManager.mettreAJourPlugin( nom, url, sha1 )
if( retour ):
self.tableWidgetPlugins.item( ligne, 0 ).setIcon( self.iconeMAJReussie )
else:
self.tableWidgetPlugins.item( ligne, 0 ).setIcon( self.iconeMAJEchouee )
ligne += 1
# On n'active pas le bouton d'installation
self.pushButtonLancerInstallation.setEnabled( False )
threading.Thread( target = threadMettreAJour, args = ( self, ) ).start()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os
import re
import shlex
import subprocess
import time
from fonctions.urlToRtmpdump import urlToRtmpdump
from PyQt4 import QtGui, QtCore
import logging
logger = logging.getLogger( __name__ )
##########
# Classe #
##########
## Classe qui gere le telechargement des fichiers
class Downloader( QtCore.QObject ):
repertoireTelechargement = ""
# Instance de la classe (singleton)
instance = None
def __new__( cls, *args, **kwargs ):
if( cls.instance is None ):
cls.instance = super( Downloader, cls ).__new__( cls, *args, **kwargs )
return cls.instance
## Constructeur
def __init__( self ):
QtCore.QObject.__init__( self )
self.arreter = True
self.process = None
## Methode pour telecharger un fichier
# @param fichier Fichier a telecharger
# @return Booleen qui indique si le telechargement a reussi
def telecharger( self, fichier ):
# Chemin complet du fichier de sortie
fichierSortie = os.path.join( self.repertoireTelechargement, getattr( fichier, "nomFichierSortie" ) )
# URL du fichier
urlFichier = str( getattr( fichier, "lien" ) )
logger.info( u"téléchargement de %s" %( urlFichier ) )
# On va creer la commande a executer pour telecharger le fichier
# L'outil va dependre du protocol
if( urlFichier[ :4 ] == "rtmp" ):
commande = '%s -o "%s"' %( urlToRtmpdump( urlFichier ), fichierSortie )
elif( urlFichier[ :4 ] == "http" or urlFichier[ :3 ] == "ftp" or urlFichier[ :3 ] == "mms" ):
commande = "msdl -c " + urlFichier + ' -o "' + fichierSortie + '"'
else:
logger.warn( u"le protocole du fichier %s n'est pas géré" %( urlFichier ) )
return False
# Commande mise au bon format pour Popen
if( not isinstance( commande, str ) ):
commande = str( commande )
# Arguments a donner a Popen
arguments = shlex.split( commande )
# On commence
self.arreter = False
# On lance la commande en redirigeant stdout et stderr (stderr va dans stdout)
self.process = subprocess.Popen( arguments, stdout = subprocess.PIPE, stderr = subprocess.STDOUT, universal_newlines = True )
# On recupere le flux stdout
stdoutF = self.process.stdout
# Tant que le subprocess n'est pas fini
while( self.process.poll() == None ):
# On lit stdout
ligne = stdoutF.readline()
# On recupere le pourcentage (s'il est affiche)
pourcentListe = re.findall( "(\d{1,3}\.{0,1}\d{0,1})%", ligne )
if( pourcentListe != [] ):
pourcent = int( float( pourcentListe[ -1 ] ) )
if( pourcent >= 0 and pourcent <= 100 ):
# On envoit le pourcentage d'avancement a l'interface
self.emit( QtCore.SIGNAL( "pourcentageFichier(int)" ), pourcent )
# On attent avant de recommencer a lire
time.sleep( 1 )
# On a fini
self.arreter = True
self.process = None
# Le telechargement s'est bien passe
return True
## Methode pour stopper le telechargement d'un fichier
def stopperTelechargement( self ):
if not self.arreter:
self.arreter = True
# On stop le process s'il est lance
if( self.process != None and self.process.poll() == None ):
self.process.terminate()
#~ self.process.kill()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import os
from PyQt4 import QtGui, QtCore
from Preferences import Preferences
from PluginManager import PluginManager
from GUI.ConvertQString import *
##########
# Classe #
##########
## Classe qui gere le dialog des preferences du logiciel
class PreferencesDialog( QtGui.QDialog ):
## Constructeur
def __init__( self, parent ):
# Appel au constructeur de la classe mere
QtGui.QDialog.__init__( self, parent )
self.preferences = Preferences()
self.pluginManager = PluginManager()
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle( u"Préférences" )
# Dimensions la fenetre
self.resize( 325, 510 )
# Mise en place de son icone
self.setWindowIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) )
###
# Mise en place des widgets dans la fenetre
###
# Layout du dialog (il ne contiendra que la scroll area)
self.layoutPrincipal = QtGui.QVBoxLayout( self )
# Scroll Area (elle ne contiendra que le widget central)
self.scrollArea = QtGui.QScrollArea( self )
self.layoutPrincipal.addWidget( self.scrollArea )
# Widget central
self.widgetCentral = QtGui.QWidget( self.scrollArea )
# Layout de grillequi contient les elements
self.gridLayout = QtGui.QGridLayout( self.widgetCentral )
# Font pour les titres
fontTitres = QtGui.QFont()
fontTitres.setPointSize( 11 )
fontTitres.setWeight( 75 )
fontTitres.setBold( True )
#
# Choix du repertoire telechargement
#
# Label
self.labelRepertoire = QtGui.QLabel( self )
self.labelRepertoire.setFont( fontTitres )
self.labelRepertoire.setText( u"Répertoire de téléchargement :" )
# Repertoire de telechargement
self.lineEditRepertoireTelechargement = QtGui.QLineEdit( self )
# Bouton pour ouvrir la fenetre de selection de repertoire
self.pushButtonSelectionDossier = QtGui.QPushButton( self )
self.pushButtonSelectionDossier.setIcon( QtGui.QIcon( "ico/gtk-folder.svg" ) )
#
# Choix du plugin par defaut
#
# Label
self.labelPluginDefaut = QtGui.QLabel( self )
self.labelPluginDefaut.setFont( fontTitres )
self.labelPluginDefaut.setText( u"Plugin par défaut :" )
# Liste de choix du plugin par defaut
self.comboBoxPluginDefaut = QtGui.QComboBox( self )
#
# Choix des plugins a activer
#
# Label
self.labelPlugins = QtGui.QLabel( self )
self.labelPlugins.setFont( fontTitres )
self.labelPlugins.setText( "Plugins actifs :" )
# Liste des plugins
self.listWidgetPlugin = QtGui.QListWidget( self )
#
# Choix des parametres Internet
#
# Label
self.labelInternet = QtGui.QLabel( self )
self.labelInternet.setFont( fontTitres )
self.labelInternet.setText( u"Paramètres Internet :" )
# Layout formulaire
self.layoutInternet = QtGui.QFormLayout()
# SpinBox pour choisir le timeOut
self.spinBoxTimeOut = QtGui.QSpinBox()
self.spinBoxTimeOut.setMinimum( 1 )
self.spinBoxTimeOut.setMaximum( 60 )
self.layoutInternet.addRow( u"Time out (en s) :", self.spinBoxTimeOut )
# SpinBox pour choisir le nombre de threads max
self.spinBoxNbThread = QtGui.QSpinBox()
self.spinBoxNbThread.setMinimum( 1 )
self.spinBoxNbThread.setMaximum( 100 )
self.layoutInternet.addRow( u"Nombre de threads max :", self.spinBoxNbThread )
# Bouton pour enregistrer/annuler les preferences
self.buttonBox = QtGui.QDialogButtonBox( self )
self.buttonBox.addButton( "Enregistrer", QtGui.QDialogButtonBox.AcceptRole )
self.buttonBox.addButton( "Fermer", QtGui.QDialogButtonBox.RejectRole )
# On ajoute le tout au layout
self.gridLayout.addWidget( self.labelRepertoire, 0, 0, 1, 2 )
self.gridLayout.addWidget( self.lineEditRepertoireTelechargement, 1, 0, 1, 1 )
self.gridLayout.addWidget( self.pushButtonSelectionDossier, 1, 1, 1, 1 )
self.gridLayout.addWidget( self.labelPluginDefaut, 2, 0, 1, 2 )
self.gridLayout.addWidget( self.comboBoxPluginDefaut, 3, 0, 1, 2 )
self.gridLayout.addWidget( self.labelPlugins, 4, 0, 1, 2 )
self.gridLayout.addWidget( self.listWidgetPlugin, 5, 0, 1, 2 )
self.gridLayout.addWidget( self.labelInternet, 6, 0, 1, 2 )
self.gridLayout.addLayout( self.layoutInternet, 7, 0, 1, 2 )
# Les boutons sont ajoutes au layout principal
self.layoutPrincipal.addWidget( self.buttonBox )
# On adapte la taille du widget
self.widgetCentral.adjustSize()
# On ajoute le widget central a la scroll area
self.scrollArea.setWidget( self.widgetCentral )
###
# Signaux provenants de l'interface
###
QtCore.QObject.connect( self.pushButtonSelectionDossier, QtCore.SIGNAL( "clicked()" ), self.afficherSelecteurDossier )
QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "accepted()" ), self.enregistrerPreferences )
QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "rejected()" ), self.reject )
## Methode pour afficher la fenetre des preferences
def afficher( self ):
# On met en place dans le textEdit le repertoire
self.lineEditRepertoireTelechargement.setText( stringToQstring( self.preferences.getPreference( "repertoireTelechargement" ) ) )
# On met en place le plugin par defaut
self.remplirPluginParDefaut()
# On met en place la liste des plugins
self.afficherPlugins()
# On met en place les valeurs des SpinBox
self.spinBoxTimeOut.setValue( self.preferences.getPreference( "timeOut" ) )
self.spinBoxNbThread.setValue( self.preferences.getPreference( "nbThreadMax" ) )
# On affiche la fenetre
self.exec_()
## Methode pour enregistrer les preferences du logiciel
def enregistrerPreferences( self ):
# On sauvegarde les valeurs des SpinBox
self.preferences.setPreference( "nbThreadMax", self.spinBoxNbThread.value() )
self.preferences.setPreference( "timeOut", self.spinBoxTimeOut.value() )
# On sauvegarde les plugins actifs
self.sauvegarderPlugins()
# On sauvegarde le plugin par defaut
self.preferences.setPreference( "pluginParDefaut", qstringToString( self.comboBoxPluginDefaut.currentText() ) )
# On sauvegarde le repertoire de telechargement
self.preferences.setPreference( "repertoireTelechargement", qstringToString( self.lineEditRepertoireTelechargement.text() ) )
# On sauvegarde dans le fichier
self.preferences.sauvegarderConfiguration()
# On masque la fenetre
self.hide()
####################################################################
# Methodes qui gerent l'emplacement de telechargement des fichiers #
####################################################################
## Methode qui affiche le selecteur de dossier
def afficherSelecteurDossier( self ):
rep = QtGui.QFileDialog.getExistingDirectory( None,
u"Sélectionnez le répertoire de téléchargement",
self.lineEditRepertoireTelechargement.text(),
QtGui.QFileDialog.ShowDirsOnly
)
# Si le repertoire existe
if( os.path.isdir( qstringToString( rep ) ) ):
self.lineEditRepertoireTelechargement.setText( rep ) # On modifie la zone de texte qui affiche le repertoire
################################################
# Methodes qui gerent la partie plugins actifs #
################################################
## Methode qui liste les plugins actif dans le listWidgetPlugin
def afficherPlugins( self ):
# On recupere les listes de plugins
listePluginsDisponibles = self.pluginManager.getListeSites()
listePluginsDisponibles.sort() # On trie cette liste
listePluginsActives = self.preferences.getPreference( "pluginsActifs" )
# On remet a 0 le listWidget
self.listWidgetPlugin.clear()
# On affiche les plugins
for plugin in listePluginsDisponibles:
# On met en place l'item
self.listWidgetPlugin.addItem( self.creerItem( plugin, plugin in listePluginsActives ) )
## Methode qui remplie la combo box du plugin par defaut
def remplirPluginParDefaut( self ):
# On efface la liste
self.comboBoxPluginDefaut.clear()
# On ajoute les plugins actifs
for plugin in self.preferences.getPreference( "pluginsActifs" ):
self.comboBoxPluginDefaut.addItem( stringToQstring( plugin ) )
# On selectionne le plugin par defaut
index = self.comboBoxPluginDefaut.findText( stringToQstring( self.preferences.getPreference( "pluginParDefaut" ) ) )
if( index != -1 ):
self.comboBoxPluginDefaut.setCurrentIndex( index )
## Methode qui sauvegarde les plugins actifs
def sauvegarderPlugins( self ):
# On liste les plugins actifs
liste = []
for i in range( self.listWidgetPlugin.count() ): # Pour chaque ligne
if( self.listWidgetPlugin.item( i ).checkState() == QtCore.Qt.Checked ): # Si elle est selectionnee
liste.append( qstringToString( self.listWidgetPlugin.item( i ).text() ) )
# On met cela en place dans les preferences
self.preferences.setPreference( "pluginsActifs", liste )
# On relance l'actualisation de l'affichage
self.emit( QtCore.SIGNAL( "actualiserListesDeroulantes()" ) )
####################
# Autres methodes #
####################
## Methode qui creer une element pour un listeWidget
# @param texte Texte de l'element
# @param checkBox Si la checkBox de l'element est cochee ou non
# @return L'element cree
def creerItem( self, texte, checkBox = False ):
# On cree l'item avec le texte
item = QtGui.QListWidgetItem( stringToQstring( texte ) )
# On centre le texte
item.setTextAlignment( QtCore.Qt.AlignCenter )
# L'item ne doit pas etre modifiable
item.setFlags( item.flags() & ~QtCore.Qt.ItemIsEditable )
# L'item doit avoir sa checkBox cochee ?
if( checkBox ):
item.setCheckState( QtCore.Qt.Checked )
else:
item.setCheckState( QtCore.Qt.Unchecked )
# On renvoie l'item
return item
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
import logging
logger = logging.getLogger( __name__ )
from PyQt4 import QtGui, QtCore
from GUI.ConvertQString import *
from API import API
from Option import Option
##########
# Classe #
##########
## Classe qui gere l'affichage des fenetres de dialog pour les preferences des plugins
class PreferencePluginDialog:
OPTION_TEXTE = 0
OPTION_CHECKBOX = 1
OPTION_LISTE = 2
OPTION_COMBOBOX = 3
## Constructeur
# @param parent Fenetre parent (MainWindow)
def __init__( self, parent ):
self.parent = parent # Dans ce cas, parent = MainWindow
self.api = API.getInstance()
##########################################################################
# Fonctions pour creer le dialog, l'afficher et en recuperer les valeurs #
##########################################################################
## Methode qui ouvre la fenetre de preference d'un plugin
# @param nomPlugin Nom du plugin pour lequel on va ouvrir la fenetre
# @param listeOptions Listes des options du plugin
def ouvrirDialogPreferences( self, nomPlugin, listeOptions ):
self.nomPluginCourant = nomPlugin
self.initDialogPreferences( nomPlugin, listeOptions )
self.dialogPreferences.exec_()
## Methode pour creer la fenetre de preference d'un plugin
# @param nomPlugin Nom du plugin pour lequel on va creer la fenetre
# @param listeOptions Listes des options du plugin
def initDialogPreferences( self, nomPlugin, listeOptions ):
# On cree un nouveau dialog
self.dialogPreferences = QtGui.QDialog( self.parent )
# On met le nom du plugin dans le titre de la fenetre
self.dialogPreferences.setWindowTitle( stringToQstring( u"Préférences de %s" %( nomPlugin ) ) )
# Change la taille
self.dialogPreferences.resize( 500, 350 )
# La liste des widgets est vide
self.listeWidget = []
# Layout du dialog (il ne contiendra que la scroll area)
self.layoutPrincipal = QtGui.QVBoxLayout( self.dialogPreferences )
# Scroll Area (elle ne contiendra que le widget central)
self.scrollArea = QtGui.QScrollArea( self.dialogPreferences )
self.layoutPrincipal.addWidget( self.scrollArea )
# Widget central
self.widgetCentral = QtGui.QWidget( self.scrollArea )
# On cree un layout de grille (layout du widget central)
self.layoutGrille = QtGui.QGridLayout( self.widgetCentral )
# On ajoute les options
for option in listeOptions:
typeOption = getattr( option, "type" )
nomOption = getattr( option, "nom" )
texteDescriptif = getattr( option, "description" )
valeurParDefaut = getattr( option, "valeur" )
valeurs = getattr( option, "choix", None )
if( typeOption == Option.TYPE_TEXTE ):
self.ajoutTexte( nomOption, texteDescriptif, valeurParDefaut )
elif( typeOption == Option.TYPE_BOULEEN ):
self.ajoutCheckBox( nomOption, texteDescriptif, valeurParDefaut )
elif( typeOption == Option.TYPE_CHOIX_MULTIPLE ):
valeursBonFormat = []
for val in valeurs:
valeursBonFormat.append( [ val, val in valeurParDefaut ] )
self.ajoutListe( nomOption, texteDescriptif, valeursBonFormat )
elif( typeOption == Option.TYPE_CHOIX_UNIQUE ):
self.ajoutComboBox( nomOption, texteDescriptif, valeurs, valeurParDefaut )
else:
logger.warn( "type d'option inconnu" )
# On ajoute les bouton Sauvegarder et Annuler
buttonBox = QtGui.QDialogButtonBox( self.dialogPreferences )
buttonBox.addButton( "Sauvegarder", QtGui.QDialogButtonBox.AcceptRole )
buttonBox.addButton( "Annuler", QtGui.QDialogButtonBox.RejectRole )
self.layoutPrincipal.addWidget( buttonBox )
# On connecte les signaux
QtCore.QObject.connect( buttonBox, QtCore.SIGNAL( "accepted()" ), self.sauvegarderPreferences )
QtCore.QObject.connect( buttonBox, QtCore.SIGNAL( "rejected()" ), self.dialogPreferences.reject )
# On adapte la taille du widget
#~ self.widgetCentral.adjustSize()
# On ajoute le widget central a la scroll area
self.scrollArea.setWidget( self.widgetCentral )
## Methode pour envoyer les nouvelles valeurs des options du plugin a API
def sauvegarderPreferences( self ):
# Pour chaque widget
for( typeWidget, widget ) in self.listeWidget:
# On recupere le nom de la preference
nomPreference = qstringToString( widget.objectName() )
# On recupere l'information qui nous interesse dans le widget et on la retourne
if( typeWidget == self.OPTION_TEXTE ):
valeurWidget = qstringToString( widget.text() )
elif( typeWidget == self.OPTION_CHECKBOX ):
valeurWidget = ( widget.checkState() == QtCore.Qt.Checked )
elif( typeWidget == self.OPTION_LISTE ):
liste = []
for i in range( widget.count() ): # Pour chaque ligne
if( widget.item( i ).checkState() == QtCore.Qt.Checked ): # Si elle est selectionnee
liste.append( qstringToString( widget.item( i ).text() ) )
valeurWidget = liste
elif( typeWidget == self.OPTION_COMBOBOX ):
valeurWidget = qstringToString( widget.currentText() )
else:
logger.warn( "type d'option inconnu" )
continue
# On envoit la nouvelle valeur
self.api.setPluginOption( self.nomPluginCourant, nomPreference, valeurWidget )
# On ferme la fenetre
self.dialogPreferences.hide()
###############################################
# Fonctions pour creer les elements du dialog #
###############################################
## Methode pour ajouter une zone de texte
# A ne pas appeler implicitement
# @param nom Nom unique de la preference
# @param texteDescriptif Texte qui presente la preference
# @param texteParDefaut Valeur par defaut du texte
def ajoutTexte( self, nom, texteDescriptif, texteParDefaut ):
# On cree le widget
widget = QtGui.QLineEdit( self.dialogPreferences )
# On met en place son nom
widget.setObjectName( stringToQstring( nom ) )
# On met en place son texte par defaut
widget.setText( stringToQstring( texteParDefaut ) )
# On l'ajoute a la liste des widgets du dialog
self.listeWidget.append( [ self.OPTION_TEXTE, widget ] )
# On cree le label qui le decrit
label = QtGui.QLabel( stringToQstring( texteDescriptif ), self.dialogPreferences )
# On ajoute le texte et le widget au layout
numeroLigne = self.layoutGrille.rowCount()
self.layoutGrille.addWidget( label, numeroLigne, 0, 1, 1 )
self.layoutGrille.addWidget( widget, numeroLigne, 1, 1, 1 )
## Methode pour ajouter une case a cocher
# A ne pas appeler implicitement
# @param nom Nom unique de la preference
# @param texteDescriptif Texte qui presente la preference
# @param valeurParDefaut Valeur par defaut (True ou False)
def ajoutCheckBox( self, nom, texteDescriptif, valeurParDefaut ):
# On cree le widget
widget = QtGui.QCheckBox( self.dialogPreferences )
#~ widget = QtGui.QCheckBox( u"Activer ?", self.dialogPreferences )
# On met en place son nom
widget.setObjectName( stringToQstring( nom ) )
# On met en place sa valeur par defaut (cochee ou non)
if( valeurParDefaut ):
widget.setCheckState( QtCore.Qt.Checked )
else:
widget.setCheckState( QtCore.Qt.Unchecked )
# On l'ajoute a la liste des widgets du dialog
self.listeWidget.append( [ self.OPTION_CHECKBOX, widget ] )
# On cree le label qui le decrit
label = QtGui.QLabel( stringToQstring( texteDescriptif ), self.dialogPreferences )
# On ajoute le texte et le widget au layout
numeroLigne = self.layoutGrille.rowCount()
self.layoutGrille.addWidget( label, numeroLigne, 0, 1, 1 )
self.layoutGrille.addWidget( widget, numeroLigne, 1, 1, 1 )
## Methode pour ajouter une liste
# A ne pas appeler implicitement
# @param nom Nom unique de la preference
# @param texteDescriptif Texte qui presente la preference
# @param valeurs Valeurs par defaut [ [ Element1, Cochee1 ? ], [ ... ] , ... ]
def ajoutListe( self, nom, texteDescriptif, valeurs ):
# On cree le widget
widget = QtGui.QListWidget( self.dialogPreferences )
# On met en place son nom
widget.setObjectName( stringToQstring( nom ) )
# On met en place ses valeurs
for( nom, cochee ) in valeurs:
widget.addItem( self.creerItem( nom, cochee ) )
# On l'ajoute a la liste des widgets du dialog
self.listeWidget.append( [ self.OPTION_LISTE, widget ] )
# On cree le label qui le decrit
label = QtGui.QLabel( stringToQstring( texteDescriptif ), self.dialogPreferences )
# On ajoute le texte et le widget au layout
numeroLigne = self.layoutGrille.rowCount()
self.layoutGrille.addWidget( label, numeroLigne, 0, 1, 2 )
self.layoutGrille.addWidget( widget, numeroLigne + 1, 0, 1, 2 )
## Methode pour ajouter une liste deroulante
# A ne pas appeler implicitement
# @param nom Nom unique de la preference
# @param texteDescriptif Texte qui presente la preference
# @param elements Element de la liste
# @param valeurParDefaut Element selectionne dans la liste
def ajoutComboBox( self, nom, texteDescriptif, elements, valeurParDefaut ):
# On cree le widget
widget = QtGui.QComboBox( self.dialogPreferences )
# On met en place son nom
widget.setObjectName( stringToQstring( nom ) )
# On ajoute tous les elements a la combo box
for elmt in elements:
widget.addItem( stringToQstring( elmt ) )
# On met en place la valeur par defaut
if not( valeurParDefaut in elements ): # Si on a pas deja la valeur par defaut dans la liste
# On l'ajoute
widget.addItem( stringToQstring( valeurParDefaut ) )
# On selectionne la valeur par defaut
widget.setCurrentIndex( widget.findText( stringToQstring( valeurParDefaut ) ) )
# On l'ajoute a la liste des widgets du dialog
self.listeWidget.append( [ self.OPTION_COMBOBOX, widget ] )
# On cree le label qui le decrit
label = QtGui.QLabel( stringToQstring( texteDescriptif ), self.dialogPreferences )
# On ajoute le texte et le widget au layout
numeroLigne = self.layoutGrille.rowCount()
self.layoutGrille.addWidget( label, numeroLigne, 0, 1, 1 )
self.layoutGrille.addWidget( widget, numeroLigne, 1, 1, 1 )
####################
# Autres fonctions #
####################
## Fonction qui creer un item pour un QListWidget
# @param texte Texte de l'element
# @param checkBox La checkbox doit-elle etre cochee ?
# @return L'element cree
def creerItem( self, texte, checkBox ):
# On cree l'item avec le texte
item = QtGui.QListWidgetItem( stringToQstring( texte ) )
# On centre le texte
item.setTextAlignment( QtCore.Qt.AlignCenter )
# L'item ne doit pas etre modifiable
item.setFlags( item.flags() & ~QtCore.Qt.ItemIsEditable )
# L'item doit avoir sa checkBox cochee ?
if( checkBox ):
item.setCheckState( QtCore.Qt.Checked )
else:
item.setCheckState( QtCore.Qt.Unchecked )
# On renvoie l'item
return item
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
from PyQt4 import QtCore
import re
import unicodedata
#############
# Fonctions #
#############
## Fonction qui transforme un string Python en QString
# @param texte Le string a transformer
# @return Le string transforme en QString
def stringToQstring( texte ):
if( isinstance( texte, str ) ):
return QtCore.QString( unicode( texte, "utf-8", "replace" ) )
else:
return QtCore.QString( texte )
## Fonction qui transforme un QString en string Python
# @param texte Le QString a transformer
# @return Le QString tranforme en string
def qstringToString( texte ):
try:
return str( texte.toUtf8() )
except UnicodeDecodeError:
return unicode( texte.toUtf8(), "utf-8" )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
from PyQt4 import QtGui, QtCore
from GUI.ConvertQString import *
#########
# Texte #
#########
texteCredits = \
u"""Développeurs :
- chaoswizard
- ggauthier.ggl
Développeur CLI :
tvelter
Plugins :
BmD_Online : Arte
Remerciements :
- wido (packager Archlinux)
- devil505 (packager Frugalware)
- paulk (packager Fedora)
- Thierry Thomas (packager FreeBSD)
"""
##########
# Classe #
##########
## Dialog A propos du programme
class AProposDialog( QtGui.QDialog ):
## Constructeur
def __init__( self ):
# Appel au constructeur de la classe mere
QtGui.QDialog.__init__( self )
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle( "A propos de TVDownloader" )
# Dimensions la fenetre
self.resize( 430, 360 )
# Mise en place de son icone
self.setWindowIcon( QtGui.QIcon( "ico/gtk-about.svg" ) )
###
# Mise en place des widgets dans la fenetre
###
# Layout de grille principal
self.gridLayout = QtGui.QGridLayout( self )
# Banniere
self.labelBanniere = QtGui.QLabel()
self.labelBanniere.setPixmap( QtGui.QPixmap( "img/banniere.png" ) )
# Onglets
self.tabWidget = QtGui.QTabWidget( self )
# Onglet Infos
#~ self.tabInfos = QtGui.QWidget()
#~ self.tabWidget.addTab( self.tabInfos, "Infos" )
#
# Onglet Crédits
#
self.tabCredits = QtGui.QWidget()
# On ajoute une zone de texte dans laquelle on ajoute les credits
self.gridLayoutCredits = QtGui.QGridLayout( self.tabCredits )
self.plainTextEditCredits = QtGui.QPlainTextEdit( self.tabCredits )
self.plainTextEditCredits.appendPlainText( texteCredits )
self.gridLayoutCredits.addWidget( self.plainTextEditCredits, 0, 0, 1, 1 )
self.tabWidget.addTab( self.tabCredits, u"Crédits" )
#
# Onglet Licence
#
self.tabLicence = QtGui.QWidget()
# On ajoute une zone de texte dans laquelle on ajoute la licence
self.gridLayoutLicence = QtGui.QGridLayout( self.tabLicence )
self.plainTextEditLicence = QtGui.QPlainTextEdit( self.tabLicence )
fichier = open( "COPYING", "rt" )
self.plainTextEditLicence.appendPlainText( fichier.read() )
fichier.close()
self.gridLayoutLicence.addWidget( self.plainTextEditLicence, 0, 0, 1, 1 )
self.tabWidget.addTab( self.tabLicence, "Licence" )
# Bouton pour fermer la fenetre
self.buttonBox = QtGui.QDialogButtonBox( self )
self.buttonBox.addButton( "Fermer", QtGui.QDialogButtonBox.AcceptRole )
# On ajoute le tout au layout
self.gridLayout.addWidget( self.labelBanniere, 0, 0, 1, 1 )
self.gridLayout.addWidget( self.tabWidget , 1, 0, 1, 1 )
self.gridLayout.addWidget( self.buttonBox , 2, 0, 1, 1 )
###
# Signaux provenants de l'interface
###
QtCore.QObject.connect( self.buttonBox, QtCore.SIGNAL( "accepted()" ), self.accept )
# On selectionne le premier onglet
self.tabWidget.setCurrentIndex( 0 )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
from PyQt4 import QtGui, QtCore
from GUI.ConvertQString import *
import logging
logger = logging.getLogger( __name__ )
##########
# Classe #
##########
## Classe heritant de QTableWidget a laquelle on va rajouter des methode specifiques
class MyQTableWidget( QtGui.QTableWidget ):
## Constructeur
# @param parent Parent (le plus souvent, c'est une fenetre ou un layout)
# @param dragndropEnable Autorise ou pas le drag n drop sur le QTableWidget
def __init__( self, parent = None, dragndropEnable = False ):
# Appel au constructeur de la classe mere
QtGui.QTableWidget.__init__( self, parent )
# On masque le numero des lignes
self.verticalHeader().setVisible( False )
# On masque le quadrillage
self.setShowGrid( False )
# Lorsque qu'on clique sur une ligne, on selectionne toute la ligne
self.setSelectionBehavior( QtGui.QAbstractItemView.SelectRows )
# On ne peut selectionner qu'une ligne a la fois
self.setSelectionMode( QtGui.QAbstractItemView.SingleSelection )
# La derniere colonne visible prend toute la place restante
self.horizontalHeader().setStretchLastSection( True )
# On alterne les couleurs des lignes
self.setAlternatingRowColors( True )
# Gestion du drag n drop
if( dragndropEnable ):
# Accepte le drag n drop
self.setDragEnabled( True )
self.viewport().setAcceptDrops( True )
# Le drag n drop ne prend en compte que les deplacements a l'interieur d'un meme QTableWidget
self.setDragDropMode( QtGui.QAbstractItemView.InternalMove )
# Affiche un indicateur visuel lors d'un drag n drop
self.setDropIndicatorShown( True )
# Gestion des lignes
# Chaque ligne va contenir dans une liste la reference de la classe qu'elle represente
self.listeClasse = []
## Methode pour creer un item
# @param texte Texte de l'item
# @param modifiable Indique si le texte peut etre modifiable
# @param checkBox Indique si l'item doit comprendre une checkbox
# @param cochee Indique si la checkbox doit etre cochee par defaut
# @return L'item cree
def creerItem( self, texte, modifiable = False, checkBox = False, cochee = False ):
# On cree l'item avec le texte
item = QtGui.QTableWidgetItem( stringToQstring( texte ) )
# On centre le texte
item.setTextAlignment( QtCore.Qt.AlignCenter )
# L'item peut etre modifiable ?
if not modifiable:
item.setFlags( item.flags() & ~QtCore.Qt.ItemIsEditable )
# L'item doit comprendre une checkbox ?
if( checkBox ):
# La checkBox doit etre cochee ?
if( cochee ):
item.setCheckState( QtCore.Qt.Checked )
else:
item.setCheckState( QtCore.Qt.Unchecked )
# On renvoie l'item
return item
##########################
# Gestion du drag n drop #
##########################
## Surcharge de la methode qui gere l'entree des drags dans le QTableWidget
# @param event Evenement
def dragEnterEvent( self, event ):
# On laisse le comportement par defaut
event.acceptProposedAction()
## Surcharge de la methode qui gere la sortie des drags du QTableWidget
# @param event Evenement
def dragLeaveEvent( self, event ):
# On ne laisse sortir aucun drag
event.ignore()
def dragMoveEvent( self, event ):
event.setDropAction( QtCore.Qt.MoveAction )
# On laisse le comportement par defaut
event.acceptProposedAction()
## Surcharge de la methode qui gere les drops
# @param event Evenement
def dropEvent( self, event ):
try:
ligneElementSelectionne = self.selectedItems()[ 0 ].row()
ligneOuDeplacerSelection = self.itemAt( event.pos() ).row()
# On recupere l'element a deplacer
#~ elementADeplacer = self.getLigne( ligneElementSelectionne )
# Si on veut descendre l'element
if( ligneOuDeplacerSelection > ligneElementSelectionne ):
# On remonte toutes les autres lignes entre l'element et sa future position
for ligne in range( ligneElementSelectionne, ligneOuDeplacerSelection ):
self.echangerLignes( ligne + 1, ligne )
# Si on veut monter l'element
elif( ligneOuDeplacerSelection < ligneElementSelectionne ):
# On descend toutes les autres lignes entre l'element et sa future position
for ligne in range( ligneElementSelectionne, ligneOuDeplacerSelection, -1 ):
self.echangerLignes( ligne, ligne - 1 )
# On met en place la ligne a deplacer
#~ self.setLigne( ligneOuDeplacerSelection, elementADeplacer )
except:
pass
# On a gere a la main le deplacement, on ignore donc l'event
event.ignore()
######################
# Gestion des lignes #
######################
## Methode pour renvoyer une ligne (a utiliser avec #setLigne)
# @param numeroLigne Numero de la ligne a renvoyer
# @return La liste des elements de la ligne + reference de la classe qu'elle represente
def getLigne( self, numeroLigne ):
liste = []
for i in range( self.columnCount() ):
liste.append( self.takeItem( numeroLigne, i ) )
return [ liste, self.listeClasse[ numeroLigne ] ]
## Methode pour copier une ligne (a utiliser avec #setLigne)
# @param numeroLigne Numero de la ligne a copier
# @return La liste des elements de la ligne + reference de la classe qu'elle represente
def copierLigne( self, numeroLigne ):
liste = []
for i in range( self.columnCount() ):
liste.append( self.item( numeroLigne, i ).clone() )
return [ liste, self.listeClasse[ numeroLigne ] ]
## Methode pour mettre en place une ligne (a utiliser avec #getLigne)
# @param numeroLigne Numero de la ligne que l'on va mettre en place
# @param listeElementsClasse Liste des elements a mettre en place sur cette ligne + reference de la classe qu'elle represente
def setLigne( self, numeroLigne, listeElementsClasse ):
nbColonnes = self.columnCount()
listeElements, classe = listeElementsClasse
# Les lignes ont le meme nombre d'elements ?
if( len( listeElements ) == nbColonnes ):
for i in range( nbColonnes ):
self.setItem( numeroLigne, i, listeElements[ i ] )
if( numeroLigne < len( self.listeClasse ) ):
self.listeClasse[ numeroLigne ] = classe
else:
self.listeClasse.append( classe )
else:
logger.warn( "probleme avec les tailles des colonnes" )
## Methode pour echanger 2 lignes
# @param numeroLigne1 Numero de la 1ere ligne
# @param numeroLigne2 Numero de la 2eme ligne
def echangerLignes( self, numeroLigne1, numeroLigne2 ):
# On s'assure qu'on essaye pas d'echanger les memes lignes
if( numeroLigne1 != numeroLigne2 ):
ligne1 = self.getLigne( numeroLigne1 )
self.setLigne( numeroLigne1, self.getLigne( numeroLigne2 ) )
self.setLigne( numeroLigne2, ligne1 )
else:
logger.warn( u"pourquoi vouloir échanger une ligne avec elle meme ?!" )
## Methode pour renvoyer la reference de la classe qui represente une ligne
# @param numeroLigne Numero de la ligne dont on veut la classe
# @return Reference sur cette classe
def getClasse( self, numeroLigne ):
return self.listeClasse[ numeroLigne ]
def getListeClasse( self ):
return self.listeClasse
## Methode pour supprimer une ligne
# @param numeroLigne Numero de la ligne a supprimer
def supprimerLigne( self, numeroLigne ):
self.removeRow( numeroLigne )
del self.listeClasse[ numeroLigne ]
## Methode pour supprimer tous les elements
def toutSupprimer( self ):
for i in range( self.rowCount() - 1, -1, -1 ): # [ nbLignes - 1, nbLignes - 2, ..., 1, 0 ]
self.removeRow( i )
del self.listeClasse[ : ]
self.adapterColonnes()
## Methode pour deplacer une ligne
# La ligne est deplacee d'un element ou a une extremite de la liste
# @param versLeHaut Indique si la ligne doit etre deplacee vers le haut ou vers le bas
# @param extremite Indique si la ligne doit etre deplacee a une extremite de la liste
def deplacerLigne( self, versLeHaut = False, extremite = False ):
# Si on a au moin un element selectionne
if( len( self.selectedItems() ) > 0 ):
numeroLigne = self.currentRow()
nbLignes = self.rowCount()
if( versLeHaut ):
# On test si un deplacement est utile
if( numeroLigne != 0 or not versLeHaut ):
if extremite:
for i in range( numeroLigne, 0, -1 ): # [ numeroLigne - 1, numeroLigne - 2, ..., 1 ]
self.echangerLignes( i, i - 1 )
self.selectRow( 0 )
else:
self.echangerLignes( numeroLigne, numeroLigne - 1 )
self.selectRow( numeroLigne - 1 )
else:
# On test si un deplacement est utile
if( numeroLigne != nbLignes - 1 or versLeHaut ):
if extremite:
for i in range( numeroLigne, nbLignes - 1 ):
self.echangerLignes( i, i + 1 )
self.selectRow( nbLignes - 1 )
else:
self.echangerLignes( numeroLigne, numeroLigne + 1 )
self.selectRow( numeroLigne + 1 )
## Methode qui adapte la taille des colonnes
def adapterColonnes( self ):
# On adapte la taille des colonnes
self.resizeColumnsToContents()
# Si on n'a pas la scroll bar
if not self.isHorizontalScrollBarVisible():
# La derniere colonne visible prend toute la place restante
self.horizontalHeader().setStretchLastSection( True )
## Methode qui determine si la scroll bar horizontale est visible
# @return Si la scroll bar horizontale est visible
def isHorizontalScrollBarVisible( self ):
isVisible = False
tailleColonnes = 0
for i in range( self.columnCount() ):
tailleColonnes += self.columnWidth( i )
tailleWidget = self.width()
if( tailleColonnes > tailleWidget ):
isVisible = True
return isVisible
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#########################################
# Licence : GPL2 ; voir fichier COPYING #
#########################################
# Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
# Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
# Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, États-Unis.
###########
# Modules #
###########
from PyQt4 import QtGui, QtCore
##########
# Classe #
##########
## Classe heritant de QPushButton
class MyQPushButton( QtGui.QPushButton ):
## Constructeur
# @param parent Parent (le plus souvent, c'est une fenetre ou un layout)
def __init__( self, *args ):
# Appel au constructeur de la classe mere
nb = len( args )
if( nb == 1 ):
QtGui.QPushButton.__init__( self, args[ 0 ] )
elif( nb == 2 ):
QtGui.QPushButton.__init__( self, args[ 0 ], args[ 1 ] )
else:
QtGui.QPushButton.__init__( self, args[ 0 ], args[ 1 ], args[ 2 ] )
# On fait en sorte que la taille du bouton s'adapte toute seule
sizePolicy = self.sizePolicy()
sizePolicy.setVerticalPolicy( QtGui.QSizePolicy.Expanding )
self.setSizePolicy( sizePolicy )
| Python |
Subsets and Splits
SQL Console for ajibawa-2023/Python-Code-Large
Provides a useful breakdown of language distribution in the training data, showing which languages have the most samples and helping identify potential imbalances across different language groups.