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 #
###########
from PyQt4 import QtGui, QtCore
import threading
import time
##########
# Classe #
##########
## Fenetre d'attente du programme
class FenetreAttenteProgressDialog( QtGui.QProgressDialog ):
## Constructeur
# @param parent Fenetre parent
def __init__( self, parent ):
# Appel au constructeur de la classe mere
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() )
# On masque le bouton annuler
self.setCancelButton( None )
# Signaux
QtCore.QObject.connect( self,
QtCore.SIGNAL( "ouvrirFenetre(PyQt_PyObject)" ),
self.ouvrirSiNecessaire )
# Etat dans lequel on veut que soit la fenetre
# !!! : L'etat dans lequel on veut qu'elle soit n'est pas forcement l'etat dans lequel elle est
self.etatOuvert = False
# Mutex
self.lock = threading.Lock()
## Surcharge de la methode appelee lors de la fermeture du dialog
# Ne doit pas etre appele explicitement
# @param evenement Evenement qui a provoque la fermeture
def closeEvent( self, evenement ):
# Si la fenetre est masquee
if( self.isHidden() ):
# On accept la fermeture
evenement.accept()
else:
# On refuse la fermeture
evenement.ignore()
## Methode pour afficher la fenetre d'attente
# @param nomSite Nom du plugin (site) qui demande la fenetre d'attente
def ouvrirFenetreAttente( self, nomSite ):
self.lock.acquire()
# On veut que la fenetre soit ouverte
self.etatOuvert = True
self.lock.release()
# On attent un peu puis on ouvre la fenetre si necessaire
threading.Timer( 0.5, self.emit, ( QtCore.SIGNAL( "ouvrirFenetre(PyQt_PyObject)" ), nomSite ) ).start()
## Methode lancee par le timer apres X seconde qui ouvre la fenetre d'attente si c'est necessaire
# @param nomSite Nom du plugin (site) qui demande la fenetre d'attente
def ouvrirSiNecessaire( self, nomSite ):
self.lock.acquire()
# Si on veut toujours que la fenetre soit ouverte, on l'ouvre !
if( self.etatOuvert ):
self.setLabelText( "Patientez pendant l'actualisation des informations de %s" %( nomSite ) )
self.show()
self.lock.release()
## Methode pour fermer la fenetre d'attente
def fermerFenetreAttente( self ):
self.lock.acquire()
self.etatOuvert = False
# Si la fenetre est affiche, on la masque apres avoir un peu attendu
if not ( self.isHidden() ):
self.hide()
self.lock.release()
| 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
import Constantes
from PyQt4 import QtGui, QtCore
from GUI.Qt.MyQPushButton import MyQPushButton
from GUI.Qt.MyQTableWidget import MyQTableWidget
from API import API
from Fichier import Fichier
from GUI.AProposDialog import AProposDialog
from GUI.ConvertQString import *
from GUI.Downloader import Downloader
from GUI.FenetreAttenteProgressDialog import FenetreAttenteProgressDialog
from GUI.PreferencePluginDialog import PreferencePluginDialog
from GUI.PreferencesDialog import PreferencesDialog
from GUI.UpdateManagerDialog import UpdateManagerDialog
from Historique import Historique
from PluginManager import PluginManager
from Preferences import Preferences
import logging
logger = logging.getLogger( __name__ )
##########
# Classe #
##########
## Fenetre principale de l'application
class MainWindow( QtGui.QMainWindow ):
## Constructeur
# Le constructeur va creer la fenetre principale en y ajoutant tous les widgets necessaires au programme
def __init__( self ):
# Appel au constructeur de la classe mere
QtGui.QMainWindow.__init__( self )
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle( "%s %s" %( Constantes.TVD_NOM, Constantes.TVD_VERSION ) )
# Mise en place de son icone
self.setWindowIcon( QtGui.QIcon( "ico/TVDownloader.png" ) )
###
# Mise en place des widgets dans la fenetre
###
# Widget central qui contiendra tout
self.centralWidget = QtGui.QWidget( self )
#
# Barre du haut
#
# Layout horizontal qui contiendra les listes deroulantes
self.horizontalLayoutBarreHaut = QtGui.QHBoxLayout()
# Liste deroulante pour choisir le site (plugin)
self.comboBoxSite = QtGui.QComboBox( self.centralWidget )
self.horizontalLayoutBarreHaut.addWidget( self.comboBoxSite )
# Liste deroulante pour choisir une chaine du site courant
self.comboBoxChaine = QtGui.QComboBox( self.centralWidget)
self.horizontalLayoutBarreHaut.addWidget( self.comboBoxChaine )
# Liste deroulante pour choisir une emission de la chaine courante
self.comboBoxEmission = QtGui.QComboBox( self.centralWidget )
self.horizontalLayoutBarreHaut.addWidget( self.comboBoxEmission )
#
# Onglets
#
# Gestionnaire onglets
self.tabWidget = QtGui.QTabWidget( self.centralWidget )
# Onglet Fichiers
self.tabFichiers = QtGui.QSplitter( self.centralWidget ) # L'onglet Fichier contient un splitter
self.tabWidget.addTab( self.tabFichiers, u"Choix des fichiers" )
# Onglet Telechargements
self.tabTelechargements = QtGui.QWidget( self.centralWidget )
self.tabWidget.addTab( self.tabTelechargements, u"Téléchargements" )
#
# Liste des fichiers
#
# Layout de grille qui contient le tableau qui liste les fichiers et ses boutons
self.gridLayoutFichiers = QtGui.QGridLayout( self.tabFichiers )
# Tableau qui contient la liste des fichiers disponibles pour l'emission courante
self.tableWidgetFichier = MyQTableWidget( self.tabFichiers )
# Il a 4 colonnes et 0 ligne (pour l'instant)
self.tableWidgetFichier.setColumnCount( 3 )
self.tableWidgetFichier.setRowCount( 0 )
# On ajoute les titres
self.tableWidgetFichier.setHorizontalHeaderItem( 0,
self.tableWidgetFichier.creerItem( "" ) )
self.tableWidgetFichier.setHorizontalHeaderItem( 1,
self.tableWidgetFichier.creerItem( "Date" ) )
self.tableWidgetFichier.setHorizontalHeaderItem( 2,
self.tableWidgetFichier.creerItem( "Emission" ) )
# La liste est triable
#~ self.tableWidgetFichier.setSortingEnabled( True )
# On l'ajoute au layout
self.gridLayoutFichiers.addWidget( self.tableWidgetFichier, 0, 1, 6, 1 )
# Icones du tableWidget
self.iconeFichier = QtGui.QIcon( "ico/gtk-file.svg" )
self.iconeAjoute = QtGui.QIcon( "ico/gtk-add.svg" )
self.iconeTelecharge = QtGui.QIcon( "ico/gtk-apply.svg" )
# Bouton pour ajouter tous les fichiers a la liste des telechargements
self.pushButtonToutAjouter = MyQPushButton( self.tabFichiers )
self.pushButtonToutAjouter.setIcon( QtGui.QIcon( "ico/gtk-add.svg" ) )
self.pushButtonToutAjouter.setToolTip( u"Ajouter tous les fichiers à la liste des téléchargements" )
self.gridLayoutFichiers.addWidget( self.pushButtonToutAjouter, 0, 0, 2, 1 )
# Bouton pour rafraichir le plugin courant
self.pushButtonRafraichirPlugin = MyQPushButton( self.tabFichiers )
self.pushButtonRafraichirPlugin.setIcon( QtGui.QIcon( "ico/gtk-refresh.svg" ) )
self.pushButtonRafraichirPlugin.setToolTip( "Rafraichir le plugin" )
self.gridLayoutFichiers.addWidget( self.pushButtonRafraichirPlugin, 2, 0, 2, 1 )
# Bouton pour ouvrir la fenetre des preferences du plugin courant
self.pushButtonPreferencesPlugin = MyQPushButton( self.tabFichiers )
self.pushButtonPreferencesPlugin.setIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) )
self.pushButtonPreferencesPlugin.setToolTip( u"Ouvrir les préférences du plugin" )
self.gridLayoutFichiers.addWidget( self.pushButtonPreferencesPlugin, 4, 0, 2, 1 )
# On met en place ce layout sur un widget (pour le splitter)
self.widgetFichiers = QtGui.QWidget( self.tabFichiers )
self.widgetFichiers.setLayout( self.gridLayoutFichiers )
#
# Descriptif des fichiers
#
# Splitter pour separer image et texte
self.splitterDescriptif = QtGui.QSplitter( self.tabFichiers )
# Label pour afficher un logo
self.logoFichierDefaut = QtGui.QPixmap()
self.logoFichierDefaut.load( "img/gtk-dialog-question.svg" )
self.labelLogo = QtGui.QLabel( self.tabFichiers )
self.labelLogo.setScaledContents( True )
self.labelLogo.setPixmap( self.logoFichierDefaut.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) )
self.splitterDescriptif.addWidget( self.labelLogo )
# Zone de texte pour afficher un descriptif
self.plainTextEdit = QtGui.QPlainTextEdit( self.tabFichiers )
self.splitterDescriptif.addWidget( self.plainTextEdit )
# Onrientation verticale du splitter
self.tabFichiers.setOrientation( QtCore.Qt.Vertical )
# On ajoute les 2 elements au splitter (qui est notre onglet)
self.tabFichiers.addWidget( self.widgetFichiers )
self.tabFichiers.addWidget( self.splitterDescriptif )
#
# Liste des telechargements
#
# Layout de grille qui contient le tableau qui liste les fichiers a telecharger + les boutons pour le controller
self.gridLayoutTelechargement = QtGui.QGridLayout( self.tabTelechargements )
# Tableau qui contient la liste des fichiers a telecharger
self.tableWidgetTelechargement = MyQTableWidget( self.tabTelechargements, True )
# Il a 3 colonnes et 0 ligne (pour l'instant)
self.tableWidgetTelechargement.setColumnCount( 3 )
self.tableWidgetTelechargement.setRowCount( 0 )
# On ajoute le titre des 3 colonnes
self.tableWidgetTelechargement.setHorizontalHeaderItem( 0,
self.tableWidgetTelechargement.creerItem( "Date" ) )
self.tableWidgetTelechargement.setHorizontalHeaderItem( 1,
self.tableWidgetTelechargement.creerItem( "Emission" ) )
self.tableWidgetTelechargement.setHorizontalHeaderItem( 2,
self.tableWidgetTelechargement.creerItem( "Etat" ) )
# On l'ajoute au layout
self.gridLayoutTelechargement.addWidget( self.tableWidgetTelechargement, 0, 1, 2, 1 )
# Bouton pour supprimer tous les elements de la liste
self.pushButtonToutSupprimer = MyQPushButton( self.tabTelechargements )
self.pushButtonToutSupprimer.setIcon( QtGui.QIcon( "ico/gtk-cancel.svg" ) )
self.pushButtonToutSupprimer.setToolTip( u"Supprimer tous les téléchargements de la liste" )
self.gridLayoutTelechargement.addWidget( self.pushButtonToutSupprimer, 0, 0, 1, 1 )
# Bouton pour ouvrir le dossier des telechargements
self.pushButtonOuvrirDossierTelechargement = MyQPushButton( self.tabTelechargements )
self.pushButtonOuvrirDossierTelechargement.setIcon( QtGui.QIcon( "ico/gtk-folder.svg" ) )
self.pushButtonOuvrirDossierTelechargement.setToolTip( u"Ouvrir le dossier des téléchargements" )
self.gridLayoutTelechargement.addWidget( self.pushButtonOuvrirDossierTelechargement, 1, 0, 1, 1 )
#
# Barre progression de telechargement d'un fichier
#
self.progressBarTelechargementFichier = QtGui.QProgressBar( self.centralWidget )
self.progressBarTelechargementFichier.setProperty( "value", 0 )
#
# Barre de progression de telechargement des fichiers
#
self.progressBarTelechargement = QtGui.QProgressBar( self.centralWidget )
self.progressBarTelechargement.setProperty( "value", 0 )
#
# Boutons du bas pour gerer ajouter/supprimer/lancer telechargements
#
# Layout horizontal qui contiendra les boutons
self.horizontalLayoutBarreBas = QtGui.QHBoxLayout()
# Bouton pour lancer les telechargements
self.pushButtonLancer = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-play-ltr.svg" ), u"Lancer téléchargement", self.centralWidget )
self.horizontalLayoutBarreBas.addWidget( self.pushButtonLancer )
# Bouton pour stopper les telechargements
self.pushButtonStop = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-stop.svg" ), u"Stopper le téléchargement", self.centralWidget )
self.pushButtonStop.setEnabled( False )
self.horizontalLayoutBarreBas.addWidget( self.pushButtonStop )
###
# Positionnement des differents widgets/layouts sur le layout de grille
###
# Layout de grille dans lequel on va placer nos widgets/layouts
self.gridLayout = QtGui.QGridLayout( self.centralWidget )
# On ajoute la barre du haut
self.gridLayout.addLayout( self.horizontalLayoutBarreHaut, 0, 0, 1, 3 )
# On ajoute le gestionnaire d'onglets
self.gridLayout.addWidget( self.tabWidget, 1, 0, 1, 3 )
# On ajoute la barre de progression de telechargement d'un fichier
self.gridLayout.addWidget( self.progressBarTelechargementFichier, 2, 0, 1, 3 )
# On ajoute la barre de progression de telechargement des fichiers
self.gridLayout.addWidget( self.progressBarTelechargement, 3, 0, 1, 3 )
# On ajoute les boutons ajouter/supprimer/lancer
self.gridLayout.addLayout( self.horizontalLayoutBarreBas, 4, 0, 1, 3 )
###
# Mise en place du central widget dans la fenetre
###
self.setCentralWidget( self.centralWidget )
###
# Mise en place du menu
###
# Menu barre
self.menubar = QtGui.QMenuBar( self )
self.menubar.setGeometry( QtCore.QRect( 0, 0, 480, 25 ) )
# Menu Fichier
self.menuFichier = QtGui.QMenu( "&Fichier", self.menubar )
self.menubar.addAction( self.menuFichier.menuAction() )
# Action Fichier -> Quitter
self.actionQuitter = QtGui.QAction( QtGui.QIcon( "ico/gtk-quit.svg" ), "&Quitter", self.menuFichier )
self.actionQuitter.setIconVisibleInMenu( True )
self.menuFichier.addAction( self.actionQuitter )
# Menu Edition
self.menuEdition = QtGui.QMenu( "&Edition", self.menubar )
self.menubar.addAction( self.menuEdition.menuAction() )
# Action Edition -> Mise a jour
self.actionMAJ = QtGui.QAction( QtGui.QIcon( "ico/gtk-refresh.svg" ), u"&Mise à jour des plugins", self.menuEdition )
self.actionMAJ.setIconVisibleInMenu( True )
self.menuEdition.addAction( self.actionMAJ )
# Action Edition -> Preferences
self.actionPreferences = QtGui.QAction( QtGui.QIcon( "ico/gtk-preferences.svg" ), u"&Préférences", self.menuEdition )
self.actionPreferences.setIconVisibleInMenu( True )
self.menuEdition.addAction( self.actionPreferences )
# Menu Aide
self.menuAide = QtGui.QMenu( "&Aide", self.menubar )
self.menubar.addAction( self.menuAide.menuAction() )
# Action Aide -> A propos
self.actionAPropos = QtGui.QAction( QtGui.QIcon( "ico/gtk-about.svg" ), u"À p&ropos", self.menuAide )
self.actionAPropos.setIconVisibleInMenu( True )
self.menuAide.addAction( self.actionAPropos )
# Ajout du menu a l'interface
self.setMenuBar( self.menubar )
################################################
# Instanciations + initialisation de variables #
################################################
# Fenetre About
self.aProposDialog = None
# Fenetre des preferences du logiciel
self.preferencesDialog = None
# Fenetre de mise a jour des plugins
self.updateManagerDialog = None
# Nom plugin courant
self.nomPluginCourant = ""
# Cache des images descriptive
# Clef : urlImage Valeur : image (binaire)
self.cacheImage = {}
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# On instancie le gestionnaire de preferences des plugins
self.preferencesPluginDialog = PreferencePluginDialog( self )
# 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()
# On instancie la fenetre d'attente
self.fenetreAttenteProgressDialog = FenetreAttenteProgressDialog( self )
# On instancie le gest
#
# Fenetre de confirmation pour quitter le logiciel
#
self.quitterMessageBox = QtGui.QMessageBox( self )
self.quitterMessageBox.setWindowTitle( "Fermeture de TVDownloader" )
self.quitterMessageBox.setText( u"Voulez-vous réellement quitter TVDownloader ?" )
self.quitterMessageBox.setInformativeText( u"Votre liste de téléchargement sera perdue" )
self.quitterMessageBox.addButton( "Oui", QtGui.QMessageBox.AcceptRole )
self.quitterMessageBox.addButton( "Non", QtGui.QMessageBox.RejectRole )
###########
# Signaux #
###########
QtCore.QObject.connect( self.comboBoxSite,
QtCore.SIGNAL( "activated(QString)" ),
self.listerChaines )
QtCore.QObject.connect( self.comboBoxChaine,
QtCore.SIGNAL( "activated(QString)" ),
self.listerEmissions )
QtCore.QObject.connect( self.comboBoxEmission,
QtCore.SIGNAL( "activated(QString)" ),
self.listerFichiers )
QtCore.QObject.connect( self.tableWidgetFichier,
QtCore.SIGNAL( "cellClicked(int,int)" ),
self.afficherInformationsFichier )
QtCore.QObject.connect( self.tableWidgetFichier,
QtCore.SIGNAL( "cellDoubleClicked(int,int)" ),
self.gererTelechargement )
QtCore.QObject.connect( self.pushButtonToutAjouter,
QtCore.SIGNAL( "clicked()" ),
self.ajouterTousLesFichiers )
QtCore.QObject.connect( self.pushButtonRafraichirPlugin,
QtCore.SIGNAL( "clicked()" ),
self.rafraichirPlugin )
QtCore.QObject.connect( self.pushButtonPreferencesPlugin,
QtCore.SIGNAL( "clicked()" ),
self.ouvrirPreferencesPlugin )
QtCore.QObject.connect( self.tableWidgetTelechargement,
QtCore.SIGNAL( "cellDoubleClicked(int,int)" ),
self.supprimerTelechargement )
QtCore.QObject.connect( self.pushButtonToutSupprimer,
QtCore.SIGNAL( "clicked()" ),
self.supprimerTousLesTelechargements )
QtCore.QObject.connect( self.pushButtonOuvrirDossierTelechargement,
QtCore.SIGNAL( "clicked()" ),
self.ouvrirRepertoireTelechargement )
QtCore.QObject.connect( self.pushButtonLancer,
QtCore.SIGNAL( "clicked()" ),
self.lancerTelechargement )
QtCore.QObject.connect( self.pushButtonStop,
QtCore.SIGNAL( "clicked()" ),
self.stopperTelechargement )
QtCore.QObject.connect( self.actionQuitter,
QtCore.SIGNAL( "triggered()" ),
self.close )
QtCore.QObject.connect( self.actionMAJ,
QtCore.SIGNAL( "triggered()" ),
self.ouvrirFenetreMiseAJour )
QtCore.QObject.connect( self.actionPreferences,
QtCore.SIGNAL( "triggered()" ),
self.ouvrirPreferencesLogiciel )
QtCore.QObject.connect( self.actionAPropos,
QtCore.SIGNAL( "triggered()" ),
self.ouvrirFenetreAPropos )
QtCore.QObject.connect( self, QtCore.SIGNAL( "listeChaines(PyQt_PyObject)" ) , self.ajouterChaines )
QtCore.QObject.connect( self, QtCore.SIGNAL( "listeEmissions(PyQt_PyObject)" ) , self.ajouterEmissions )
QtCore.QObject.connect( self, QtCore.SIGNAL( "listeFichiers(PyQt_PyObject)" ) , self.ajouterFichiers )
QtCore.QObject.connect( self, QtCore.SIGNAL( "nouvelleImage(PyQt_PyObject)" ) , self.mettreEnPlaceImage )
QtCore.QObject.connect( self, QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ) , self.fenetreAttenteProgressDialog.ouvrirFenetreAttente )
QtCore.QObject.connect( self, QtCore.SIGNAL( "finActualisation()" ) , self.fenetreAttenteProgressDialog.fermerFenetreAttente )
QtCore.QObject.connect( self, QtCore.SIGNAL( "actualiserListesDeroulantes()" ) , self.actualiserListesDeroulantes )
QtCore.QObject.connect( self, QtCore.SIGNAL( "debutTelechargement(PyQt_PyObject)" ) , self.debutTelechargement )
QtCore.QObject.connect( self, QtCore.SIGNAL( "finTelechargement(PyQt_PyObject,bool)" ) , self.finTelechargement )
QtCore.QObject.connect( self, QtCore.SIGNAL( "finDesTelechargements()" ) , self.activerDesactiverInterface )
QtCore.QObject.connect( self.downloader, QtCore.SIGNAL( "pourcentageFichier(int)" ) , self.progressBarTelechargementFichier.setValue )
#########
# Début #
#########
# La fenetre prend la dimension qu'elle avait a sa fermeture
taille = self.preferences.getPreference( "tailleFenetre" )
self.resize( taille[ 0 ], taille[ 1 ] )
# Si aucun plugin n'est active, on ouvre la fenetre des preferences
if( len( self.preferences.getPreference( "pluginsActifs" ) ) == 0 ):
self.ouvrirPreferencesLogiciel()
# On actualise tous les plugins
self.rafraichirTousLesPlugins()
## Methode qui execute les actions necessaires avant de quitter le programme
def actionsAvantQuitter( self ):
# On sauvegarde les options des plugins
self.api.fermeture()
# On sauvegarde la taille de la fenetre
taille = self.size()
self.preferences.setPreference( "tailleFenetre", [ taille.width(), taille.height() ] )
# On sauvegarde les options du logiciel
self.preferences.sauvegarderConfiguration()
# On sauvegarde l'historique
self.historique.sauverHistorique()
# On stoppe les telechargements
self.stopperTelechargement()
#########################################
# Surcharge des methodes de QMainWindow #
#########################################
## Surcharge de la methode appelee lors de la fermeture de la fenetre
# Ne doit pas etre appele explicitement
# @param evenement Evenement qui a provoque la fermeture
def closeEvent( self, evenement ):
# On affiche une fenetre pour demander la fermeture si des fichiers sont dans la liste de telechargement
if( self.tableWidgetTelechargement.rowCount() > 0 ):
# On affiche une fenetre qui demande si on veut quitter
retour = self.quitterMessageBox.exec_()
# Si on veut quitter
if( retour == 0 ):
# On execute les actions necessaires
self.actionsAvantQuitter()
# On accept la fermeture
evenement.accept()
else:
# On refuse la fermeture
evenement.ignore()
else: # S'il n'y a pas de fichier
# On execute les actions necessaires
self.actionsAvantQuitter()
# On accept la fermeture
evenement.accept()
##############################################
# Methodes pour remplir les menus deroulants #
##############################################
## Methode qui actualise les listes deroulantes
def actualiserListesDeroulantes( self ):
# On lance juste l'ajout des sites en se basant sur les plugins actifs
self.ajouterSites( self.preferences.getPreference( "pluginsActifs" ) )
## Methode qui lance le listage des chaines
# @param site Nom du plugin/site pour lequel on va lister les chaines
def listerChaines( self, site ):
def threadListerChaines( self, nomPlugin ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), nomPlugin )
try:
listeChaines = self.api.getPluginListeChaines( nomPlugin )
except:
listeChaines = []
logger.error( u"impossible de récupérer la liste des chaines de %s" %( nomPlugin ) )
self.emit( QtCore.SIGNAL( "listeChaines(PyQt_PyObject)" ), listeChaines )
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
if( site != "" ):
self.nomPluginCourant = qstringToString( site )
threading.Thread( target = threadListerChaines, args = ( self, self.nomPluginCourant ) ).start()
# On active (ou pas) le bouton de preference du plugin
self.pushButtonPreferencesPlugin.setEnabled( self.api.getPluginListeOptions( self.nomPluginCourant ) != [] )
## Methode qui lance le listage des emissions
# @param chaine Nom de la chaine pour laquelle on va lister les emissions
def listerEmissions( self, chaine ):
def threadListerEmissions( self, nomPlugin, chaine ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), nomPlugin )
try:
listeEmissions = self.api.getPluginListeEmissions( nomPlugin, chaine )
except:
listeEmissions = []
logger.error( u"impossible de récupérer la liste des emissions de %s" %( nomPlugin ) )
self.emit( QtCore.SIGNAL( "listeEmissions(PyQt_PyObject)" ), listeEmissions )
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
if( chaine != "" ):
threading.Thread( target = threadListerEmissions, args = ( self, self.nomPluginCourant, qstringToString( chaine ) ) ).start()
## Methode qui lance le listage des fichiers
# @param emission Nom de l'emission pour laquelle on va lister les fichiers
def listerFichiers( self, emission ):
def threadListerFichiers( self, nomPlugin, emission ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), nomPlugin )
try:
listeFichiers = self.api.getPluginListeFichiers( nomPlugin, emission )
except:
listeFichiers = []
logger.error( u"impossible de récupérer la liste des fichiers de %s" %( nomPlugin ) )
self.emit( QtCore.SIGNAL( "listeFichiers(PyQt_PyObject)" ), listeFichiers )
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
if( emission != "" ):
threading.Thread( target = threadListerFichiers, args = ( self, self.nomPluginCourant, qstringToString( emission ) ) ).start()
## Methode qui met en place une liste de sites sur l'interface
# @param listeSites Liste des sites a mettre en place
def ajouterSites( self, listeSites ):
# On efface la liste des sites
self.comboBoxSite.clear()
# On met en place les sites
for site in listeSites:
self.comboBoxSite.addItem( stringToQstring( site ) )
# On selectionne par defaut celui choisis dans les preference
index = self.comboBoxSite.findText( stringToQstring( self.preferences.getPreference( "pluginParDefaut" ) ) )
if( index != -1 ):
self.comboBoxSite.setCurrentIndex( index )
# On lance l'ajout des chaines
self.listerChaines( self.comboBoxSite.currentText() )
## Methode qui met en place une liste de chaines sur l'interface
# @param listeChaines Liste des chaines a mettre en place
def ajouterChaines( self, listeChaines ):
# On trie la liste des chaines
listeChaines.sort()
# On efface la liste des chaines
self.comboBoxChaine.clear()
# On efface la liste des emissions
self.comboBoxEmission.clear()
# On efface la liste des fichiers
self.tableWidgetFichier.toutSupprimer()
# On met en place les chaines
for chaine in listeChaines:
self.comboBoxChaine.addItem( stringToQstring( chaine ) )
# Si on a juste une seule chaine
if( self.comboBoxChaine.count() == 1 ):
# On lance l'ajout des emissions
self.listerEmissions( self.comboBoxChaine.currentText() )
else:
# On ne selectionne pas de chaine
self.comboBoxChaine.setCurrentIndex( -1 )
## Methode qui met en place une liste d'emissions sur l'interface
# @param listeEmissions Liste des emissions a mettre en place
def ajouterEmissions( self, listeEmissions ):
# On trie la liste des emissions
listeEmissions.sort()
# On efface la liste des emissions
self.comboBoxEmission.clear()
# On efface la liste des fichiers
self.tableWidgetFichier.toutSupprimer()
# On met en place la liste des emissions
for emission in listeEmissions:
self.comboBoxEmission.addItem( stringToQstring( emission ) )
# Si on a juste une seule emission
if( self.comboBoxEmission.count() == 1 ):
# On lance l'ajout des fichiers
self.listerFichiers( self.comboBoxEmission.currentText() )
else:
# On ne selectionne pas d'emission
self.comboBoxEmission.setCurrentIndex( -1 )
###############################################
# Methodes pour remplir la liste des fichiers #
###############################################
## Methode pour ajouter des fichiers a l'interface
# @param listeFichiers Liste des fichiers a ajouter
def ajouterFichiers( self, listeFichiers ):
# On efface la liste des fichiers
self.tableWidgetFichier.toutSupprimer()
# On commence au depart
ligneCourante = 0
# On met en place chacun des fichiers
for fichier in listeFichiers:
# On ajoute une ligne
self.tableWidgetFichier.insertRow( ligneCourante )
# On ajoute les informations au tableWidgetFichier
liste = []
liste.append( self.tableWidgetFichier.creerItem( "" ) )
liste.append( self.tableWidgetFichier.creerItem( getattr( fichier, "date" ) ) )
liste.append( self.tableWidgetFichier.creerItem( getattr( fichier, "nom" ) ) )
self.tableWidgetFichier.setLigne( ligneCourante, [ liste, fichier ] )
# On met en place l'icone qui va bien
self.gererIconeListeFichier( fichier )
ligneCourante += 1
# On adapte la taille des colonnes
self.tableWidgetFichier.adapterColonnes()
## Methode qui rafraichit le plugin courant
def rafraichirPlugin( self ):
def threadRafraichirPlugin( self, nomPlugin ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), nomPlugin )
try:
self.api.pluginRafraichir( nomPlugin )
except:
logger.error( "impossible de rafraichir le plugin %s" %( nomPlugin ) )
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
threading.Thread( target = threadRafraichirPlugin, args = ( self, self.nomPluginCourant ) ).start()
## Methode qui met en place l'image de la description d'un fichier
# @param image Image a mettre en place (binaire)
def mettreEnPlaceImage( self, image ):
logoFichier = QtGui.QPixmap()
logoFichier.loadFromData( image )
self.labelLogo.setPixmap( logoFichier.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) )
## Methode qui affiche des informations sur le fichier selectionne
def afficherInformationsFichier( self, ligne, colonne ):
def threadRecupererImage( self, urlImage ):
image = self.api.getPicture( urlImage )
if( image != "" ):
self.cacheImage[ urlImage ] = image
self.emit( QtCore.SIGNAL( "nouvelleImage(PyQt_PyObject)" ), image )
else:
# Afficher image par defaut
pass
fichier = self.tableWidgetFichier.getClasse( ligne )
# On recupere le lien de l'image et le texte descriptif
urlImage = getattr( fichier, "urlImage" )
texteDescriptif = getattr( fichier, "descriptif" )
self.plainTextEdit.clear()
# Si on a un texte descriptif, on l'affiche
if( texteDescriptif != "" ):
self.plainTextEdit.appendPlainText( stringToQstring( texteDescriptif ) )
else:
self.plainTextEdit.appendPlainText( u"Aucune information disponible" )
# Si on n'a pas d'image
if( urlImage == "" ):
# On met en place celle par defaut
self.logoFichier = self.logoFichierDefaut
self.labelLogo.setPixmap( self.logoFichier.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) )
else: # Si on en a une
# Si elle est dans le cache des images
if( self.cacheImage.has_key( urlImage ) ):
self.mettreEnPlaceImage( self.cacheImage[ urlImage ] )
else: # Sinon
# On lance le thread pour la recuperer
threading.Thread( target = threadRecupererImage, args = ( self, urlImage ) ).start()
## Methode qui gere l'icone d'un fichier dans la liste des telechargements
# Il y a 3 icones possible :
# - C'est un fichier
# - C'est un fichier present dans l'historique (donc deja telecharge)
# - C'est un fichier present dans la liste des telechargements
# @param fichier Fichier a gerer
def gererIconeListeFichier( self, fichier ):
if( fichier in self.tableWidgetFichier.getListeClasse() ):
ligneFichier = self.tableWidgetFichier.getListeClasse().index( fichier )
# On cherche quel icone mettre en place
if( fichier in self.tableWidgetTelechargement.getListeClasse() ):
icone = self.iconeAjoute
elif( self.historique.comparerHistorique( fichier ) ):
icone = self.iconeTelecharge
else:
icone = self.iconeFichier
# On met en place l'icone
self.tableWidgetFichier.item( ligneFichier, 0 ).setIcon( icone )
######################################################
# Methodes pour remplir la liste des telechargements #
######################################################
## Methode qui gere la liste des telechargements
# @param ligne Numero de la ligne (dans la liste des fichiers) de l'element a ajouter
# @param colonne Numero de colonne (inutile, juste pour le slot)
def gererTelechargement( self, ligne, colonne = 0 ):
fichier = self.tableWidgetFichier.getClasse( ligne )
# Si le fichier est deja dans la liste des telechargements
if( fichier in self.tableWidgetTelechargement.getListeClasse() ):
ligneTelechargement = self.tableWidgetTelechargement.getListeClasse().index( fichier )
self.supprimerTelechargement( ligneTelechargement )
else: # S'il n'y est pas, on l'ajoute
numLigne = self.tableWidgetTelechargement.rowCount()
# On insere une nouvelle ligne dans la liste des telechargements
self.tableWidgetTelechargement.insertRow( numLigne )
# On y insere les elements qui vont biens
self.tableWidgetTelechargement.setLigne( numLigne,
[
[ self.tableWidgetTelechargement.creerItem( getattr( fichier, "date" ) ),
self.tableWidgetTelechargement.creerItem( getattr( fichier, "nom" ) ),
self.tableWidgetTelechargement.creerItem( u"En attente de téléchargement" )
],
fichier
]
)
# On adapte la taille des colonnes
self.tableWidgetTelechargement.adapterColonnes()
# On modifie l'icone dans la liste des fichiers
self.gererIconeListeFichier( fichier )
## Methode qui ajoute tous les fichiers a la liste des telechargements
def ajouterTousLesFichiers( self ):
for i in range( self.tableWidgetFichier.rowCount() ):
self.gererTelechargement( i )
## Methode qui supprime un fichier de la liste des telechargements
# @param ligne Numero de la ligne a supprimer
# @param colonne Numero de colonne (inutile, juste pour le slot)
def supprimerTelechargement( self, ligne, colonne = 0 ):
fichier = self.tableWidgetTelechargement.getClasse( ligne )
# On supprime l'element du tableWidgetTelechargement
self.tableWidgetTelechargement.supprimerLigne( ligne )
# On modifie l'icone dans la liste des fichiers
self.gererIconeListeFichier( fichier )
## Methode qui supprime tous les telechargement de la liste des telechargements
def supprimerTousLesTelechargements( self ):
for i in range( self.tableWidgetTelechargement.rowCount() -1, -1, -1 ):
self.supprimerTelechargement( i )
## Methode qui lance le telechargement des fichiers
def lancerTelechargement( self ):
def threadTelechargement( self, listeFichiers ):
for fichier in listeFichiers:
# On debute un telechargement
self.emit( QtCore.SIGNAL( "debutTelechargement(PyQt_PyObject)" ), fichier )
# On le lance
retour = self.downloader.telecharger( fichier )
# On a fini le telechargement
self.emit( QtCore.SIGNAL( "finTelechargement(PyQt_PyObject,bool)" ), fichier, retour )
# On a fini les telechargements
self.emit( QtCore.SIGNAL( "finDesTelechargements()" ) )
# On liste les fichiers a telecharger
listeFichiers = []
for i in range( self.tableWidgetTelechargement.rowCount() ): # Pour chaque ligne
listeFichiers.append( self.tableWidgetTelechargement.getClasse( i ) )
nbATelecharger = len( listeFichiers )
# Si on a des elements a charger
if( nbATelecharger > 0 ):
# On met en place la valeur du progressBar
self.progressBarTelechargement.setMaximum( nbATelecharger )
self.progressBarTelechargement.setValue( 0 )
# On active/desactive ce qui va bien sur l'interface
self.activerDesactiverInterface( True )
# On lance le telechargement
threading.Thread( target = threadTelechargement, args = ( self, listeFichiers ) ).start()
## Methode qui stoppe le telechargement
def stopperTelechargement( self ):
# On stoppe le telechargement
self.downloader.stopperTelechargement()
############################################
# Methodes pour ouvrir les autres fenetres #
############################################
#
# Fenetre About
#
## Methode pour afficher la fenetre About
def ouvrirFenetreAPropos( self ):
if( self.aProposDialog == None ):
self.aProposDialog = AProposDialog()
self.aProposDialog.show()
#
# Fenetre de preference du logiciel
#
## Methode pour ouvrir les preferences du logiciel
def ouvrirPreferencesLogiciel( self ):
if( self.preferencesDialog == None ):
# On cree l'instance
self.preferencesDialog = PreferencesDialog( self )
# On connecte le signal qui va bien
QtCore.QObject.connect( self.preferencesDialog, QtCore.SIGNAL( "actualiserListesDeroulantes()" ) , self.actualiserListesDeroulantes )
self.preferencesDialog.afficher()
#
# Fenetre de mise a jour des plugins
#
## Methode pour ouvrir la fenetre de mise a jour des plugins
def ouvrirFenetreMiseAJour( self ):
if( self.updateManagerDialog == None ):
self.updateManagerDialog = UpdateManagerDialog( self )
self.updateManagerDialog.afficher()
#
# Fenetre de preference des plugins
#
## Methode pour ouvrir les preferences du plugin courant
def ouvrirPreferencesPlugin( self ):
listeOptions = self.api.getPluginListeOptions( self.nomPluginCourant )
self.preferencesPluginDialog.ouvrirDialogPreferences( self.nomPluginCourant, listeOptions )
#########
# Slots #
#########
## Methode qui ouvre le repertoire de telechargement
def ouvrirRepertoireTelechargement( self ):
QtGui.QDesktopServices.openUrl( QtCore.QUrl.fromLocalFile( stringToQstring( self.preferences.getPreference( "repertoireTelechargement" ) ) ) )
## Methode qui rafraichit le plugin courant
def rafraichirPlugin( self ):
def threadRafraichirPlugin( self, nomPlugin ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), nomPlugin )
self.api.pluginRafraichir( nomPlugin )
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
threading.Thread( target = threadRafraichirPlugin, args = ( self, self.nomPluginCourant ) ).start()
## Methode qui rafraichit tous les plugins
# A utiliser au lancement du programme
def rafraichirTousLesPlugins( self ):
def threadRafraichirTousLesPlugins( self ):
self.emit( QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ), "TVDownloader" )
self.api.pluginRafraichirAuto()
self.emit( QtCore.SIGNAL( "finActualisation()" ) )
self.emit( QtCore.SIGNAL( "actualiserListesDeroulantes()" ) )
threading.Thread( target = threadRafraichirTousLesPlugins, args = ( self, ) ).start()
## Slot qui active/desactive des elements de l'interface pendant un telechargement
# @param telechargementEnCours Indique si on telecharge ou pas
def activerDesactiverInterface( self, telechargementEnCours = False ):
# Les boutons
self.pushButtonLancer.setEnabled( not telechargementEnCours )
self.pushButtonStop.setEnabled( telechargementEnCours )
self.pushButtonToutSupprimer.setEnabled( not telechargementEnCours )
# Le table widget
self.tableWidgetTelechargement.setEnabled( not telechargementEnCours )
## Slot appele lors ce qu'un le debut d'un telechargement commence
# @param fichier Fichier dont le telechargement vient de commencer
def debutTelechargement( self, fichier ):
ligneTelechargement = self.tableWidgetTelechargement.getListeClasse().index( fichier )
self.tableWidgetTelechargement.item( ligneTelechargement, 2 ).setText( stringToQstring( u"Téléchargement en cours..." ) )
self.tableWidgetTelechargement.adapterColonnes()
self.progressBarTelechargementFichier.setValue( 0 )
## Slot appele lorsqu'un telechargement se finit
# @param fichier Fichier du telechargement qui vient de se finir
# @param reussi Indique si le telechargement s'est fini sans problemes
def finTelechargement( self, fichier, reussi = True ):
ligneTelechargement = self.tableWidgetTelechargement.getListeClasse().index( fichier )
# On ajoute le fichier a l'historique
self.historique.ajouterHistorique( fichier )
# On modifie l'icone dans la liste des fichiers
self.gererIconeListeFichier( fichier )
# On modifie l'interface
self.tableWidgetTelechargement.item( ligneTelechargement, 2 ).setText( stringToQstring( u"Fini !" ) )
self.progressBarTelechargement.setValue( self.progressBarTelechargement.value() + 1 )
self.tableWidgetTelechargement.adapterColonnes()
self.progressBarTelechargementFichier.setValue( 100 )
| 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( __name__ )
##########
# 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 -*-
#########################################
# 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.
# N.B. :
# La gestion des plugins s'appuie sur cet article :
# http://lucumr.pocoo.org/2006/7/3/python-plugin-system
###########
# Modules #
###########
from string import find
import os
import sys
from API import API
from Plugin import Plugin
import Constantes
import logging
logger = logging.getLogger( __name__ )
##########
# Classe #
##########
## 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__( self, *args, **kwargs ):
if( self.instance is None ):
self.instance = super( PluginManager, self ).__new__( self )
return self.instance
## Constructeur
def __init__( self ):
self.api = API.getInstance()
self.listePlugins = {} # Clef : nomPlugin ; Valeur : classe du plugin (!= de son instance)
self.listeInstances = {} # Clef : nomPlugin ; Valeur : son instance
# On importe tous les plugins
for rep in Constantes.REPERTOIRES_PLUGINS:
# On 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 ) )
# On l'ajoute au path si necessaire
if not( rep in sys.path ):
sys.path.insert( 0, rep )
# On importe les plugins
self.importPlugins( rep )
# On liste les plugins
self.listerPlugins()
## Methode qui importe les plugins
# @param rep Repertoire dans lequel se trouvent les plugins a importer
def importPlugins( 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 ] ) ) ):
# 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 # On passe au suivant
try :
__import__( fichier.replace( ".py", "" ), None, None, [ '' ] )
except ImportError :
logger.error( "impossible d'importer le fichier %s" %( fichier ) )
continue
## Methode qui retourne la liste des sites/plugins
# N.B. : On doit d'abord importer les plugins
# @return La liste des noms des plugins
def getListeSites( self ):
return self.listePlugins.keys()
## Methode qui liste les plugins
def listerPlugins( self ):
for plugin in Plugin.__subclasses__(): # Pour tous les plugins
# On l'instancie
inst = plugin()
# On recupere son nom
nom = getattr( inst, "nom" )
# On ajoute le plugin a la liste des plugins existants
self.listePlugins[ nom ] = plugin
## Methode pour activer un plugin
# @param nomPlugin Nom du plugin a activer
def activerPlugin( self, nomPlugin ):
if( self.listePlugins.has_key( nomPlugin ) ):
instance = self.listePlugins[ nomPlugin ]()
# On l'ajoute a la liste des instances
self.listeInstances[ nomPlugin ] = instance
# On l'ajoute a l'API
self.api.ajouterPlugin( instance )
self.api.activerPlugin( nomPlugin )
else:
logger.warn( "impossible d'activer le plugin %s" %( nomPlugin ) )
## Methode qui desactive un plugin
# @param nomPlugin Nom du plugin a desactiver
def desactiverPlugin( self, nomPlugin ):
# On le desactive dand l'API
self.api.desactiverPlugin( nomPlugin )
# On le supprime de la liste des instances
if( self.listeInstances.has_key( nomPlugin ) ):
self.listeInstances.pop( nomPlugin )
else:
logger.warn( "impossible de desactiver le plugin %s" %( nomPlugin ) )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import unittest
import sys
if not( "../" in sys.path ):
sys.path.insert( 0, "../" )
from Historique import Historique
from Fichier import Fichier
##########
# Classe #
##########
## Classe qui gere les tests de la classe Historique
class HistoriqueTests( unittest.TestCase ):
## Initialisation
def setUp( self ):
self.historique = Historique()
## Fin
def tearDown( self ):
pass
def testSingleton( self ):
"""Test si le pattern singleton est bien en place"""
self.assertEqual( id( self.historique ), id( Historique() ) )
def testMauvaisType( self ):
"""Test si l'historique renvoit bien faux si on lui demande s'il contient une variable qui n'est pas un fichier"""
variable = "jeSuisUnString"
self.assertEqual( self.historique.comparerHistorique( variable ), False )
def testPresenceElement( self ):
"""Test si l'historique est capable de retrouver un element"""
element = Fichier( "Napoleon", "1804", "Notre Dame", "Sacre Napoleon" )
# On ajoute l'element a l'historique
self.historique.ajouterHistorique( element )
# On verifie si l'element y est present
self.assertEqual( self.historique.comparerHistorique( element ), True )
if __name__ == "__main__" :
unittest.main() | Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import unittest
from PreferencesTests import PreferencesTests
from HistoriqueTests import HistoriqueTests
#########
# Debut #
#########
unittest.main() | Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
from API import API
from Navigateur import Navigateur
from time import time, sleep
urlsDifferentHost = ["http://www.google.fr/",
"http://fr.yahoo.com/",
"http://www.bing.com/",
"http://www.ubuntu-fr.org/",
"http://www.canalplus.fr/",
"http://www.m6.fr/",
"http://www.w9.fr/",
"http://www.tf1.fr/",
"http://www.france2.fr/",
"http://www.france3.fr/",
"http://www.france4.fr/",
"http://www.france5.fr/",
"http://www.franceo.fr/"]
urlsSameHost = ["http://www.canalplus.fr/c-divertissement/pid1784-les-guignols-de-l-info.html?",
"http://www.canalplus.fr/c-divertissement/pid1778-pepites-sur-le-net.html?",
"http://www.canalplus.fr/c-divertissement/pid3279-reperages-l-emission.html?",
"http://www.canalplus.fr/c-divertissement/pid2053-stephane-guillon.html?",
"http://www.canalplus.fr/c-divertissement/pid3591-une-minute-avant.html?",
"http://www.canalplus.fr/c-divertissement/pid3403-c-air-guitar-2010.html",
"http://www.canalplus.fr/c-divertissement/pid3299-album-de-la-semaine.html?",
"http://www.canalplus.fr/c-divertissement/pid3301-concert-prive.html?",
"http://www.canalplus.fr/c-divertissement/pid3535-c-la-musicale.html",
"http://www.canalplus.fr/c-divertissement/pid3308-la-radio-de-moustic.html?",
"http://www.canalplus.fr/c-divertissement/pid3298-coming-next.html?",
"http://www.canalplus.fr/c-divertissement/pid3522-u2-en-concert.html?",
"http://www.canalplus.fr/c-divertissement/pid3303-le-live-du-grand-journal.html?"]
navigateur = Navigateur()
api = API.getInstance()
def testeMechanize(urls):
reponses = {}
for url in urls:
reponses[ url ] = navigateur.getPage( url )
def testeGetPage(urls):
reponses = {}
for url in urls:
reponses[ url ] = api.getPage( url )
def testeGetPages(urls):
reponses = api.getPages(urls)
#~ t = time()
print "Url sur différent serveur:"
sleep(1)
t = time()
testeMechanize(urlsDifferentHost)
print "Mechanize:",time()-t,"secondes"
#~
sleep(1)
t = time()
testeGetPage(urlsDifferentHost)
print "getPage:",time()-t,"secondes"
#~
sleep(1)
t = time()
testeGetPages(urlsDifferentHost)
print "getPages:",time()-t,"secondes"
#~ print "\nUrl sur un même serveur:"
#~ sleep(1)
#~ t = time()
#~ testeMechanize(urlsSameHost)
#~ print "Mechanize:",time()-t,"secondes"
#~
#~ sleep(1)
#~ t = time()
#~ testeGetPage(urlsSameHost)
#~ print "getPage:",time()-t,"secondes"
#~
#~ sleep(1)
#~ t = time()
#~ testeGetPages(urlsSameHost)
#~ print "getPages:",time()-t,"secondes"
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import unittest
import sys
if not( "../" in sys.path ):
sys.path.insert( 0, "../" )
from Preferences import Preferences
##########
# Classe #
##########
## Classe qui gere les tests de la classe Preferences
class PreferencesTests( unittest.TestCase ):
## Initialisation
def setUp( self ):
self.preferences = Preferences()
## Fin
def tearDown( self ):
pass
def testSingleton( self ):
"""Test si le pattern singleton est bien en place"""
self.assertEqual( id( self.preferences ), id( Preferences() ) )
def testSauvegarde( self ):
"""Test si les preferences sont bien sauvegardees"""
listePreferences = getattr( self.preferences, "preferences" )
nomPreference = listePreferences.keys()[ 0 ]
nouvelleValeur = "ValeurDeTest"
# On met en place la preference
self.preferences.setPreference( nomPreference, nouvelleValeur )
# On verifie qu'elle est bien en place
self.assertEqual( nouvelleValeur, self.preferences.getPreference( nomPreference ) )
if __name__ == "__main__" :
unittest.main() | 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 sys
import os.path
import atexit
from lib.dialog import Dialog
from API import API
from Downloader import Downloader
from Historique import Historique
from Preferences import Preferences
##########
# Classe #
##########
## Classe qui gere la version CLI de TVDownloader
class CLIDialog():
## Constructeur
def __init__( self ):
# On cree l'instance de la classe dialog
self.dialog = Dialog()
self.dialog.setBackgroundTitle( "TVDownloader" )
# On recupere l'instance de API
self.api = API.getInstance()
# On instancie le gestionnaire de download
self.downloader = Downloader()
# On instancie le gestionnaire d'historique
self.historique = Historique()
# On instancie le gestionnaire de preferences
self.preferences = Preferences()
# Liste des telechargements
self.listeTelechargements = []
# Quand le programme se termine, on execute la fonction actionsAvantQuitter
atexit.register( self.actionsAvantQuitter )
# On commence
self.bouclePrincipale()
## Debut
def bouclePrincipale( self ):
choix = ( 1, "" )
while( choix != ( 0, "Quitter" ) ):
# On affiche le menu principal
choix = self.dialog.menu( text = "Menu Principal" ,
choices = [ [ "Commencer", "Afficher la liste des plugins" ],
[ "Téléchargements", "Gérer les téléchargements" ],
[ "Préférences", "Modifier les préférences" ],
[ "Quitter", "Quitter TVDownloader" ],
]
)
# On lance la methode qui va bien
if( choix == ( 0, "Commencer" ) ):
self.utilisationPlugins()
elif( choix == ( 0, "Téléchargements" ) ):
self.utlisationTelechargements()
elif( choix == ( 0, "Préférences" ) ):
pass
elif( choix == ( 0, "Quitter" ) ):
# Rien a faire, atexit gere cela
pass
## Methode pour selectionner les fichiers a telecharger avec les plugins
def utilisationPlugins( self ):
# Liste des plugins actifs
listePlugins = []
for nomPlugin in self.preferences.getPreference( "pluginsActifs" ):
listePlugins.append( [ nomPlugin, "" ] )
choixPlugin = ( 0, "" )
while( choixPlugin[ 0 ] != 1 ):
# On affiche le menu de selection de plugins
choixPlugin = self.dialog.menu( text = "De quelle plugin voulez-vous voir les chaines ?",
choices = listePlugins
)
if( choixPlugin[ 0 ] != 1 ):
# Liste des chaines du plugin
listeChaines = []
for nomChaine in self.api.getPluginListeChaines( choixPlugin[ 1 ] ):
listeChaines.append( [ nomChaine, "" ] )
choixChaine = ( 0, "" )
while( choixChaine[ 0 ] != 1 ):
# On affiche le menu de selection de la chaine
choixChaine = self.dialog.menu( text = "De quelle chaine voulez-vous voir les emissions ?",
choices = listeChaines
)
if( choixChaine[ 0 ] != 1 ):
# Liste des emissions de la chaine
listeEmissions = []
for nomEmission in self.api.getPluginListeEmissions( choixPlugin[ 1 ], choixChaine[ 1 ] ):
listeEmissions.append( [ nomEmission, "" ] )
choixEmission = ( 0, "" )
while( choixEmission[ 0 ] != 1 ):
# On affiche le menu de selection de l'emission
choixEmission = self.dialog.menu( text = "De quelle emission voulez-vous voir les fichiers ?",
choices = listeEmissions
)
if( choixEmission[ 0 ] != 1 ):
listeFichiersAAfficher = []
listeFichiersCoches = []
listeFichiersPrecedementCoches = []
listeFichiersAPI = self.api.getPluginListeFichiers( choixPlugin[ 1 ], choixEmission[ 1 ] )
i = 0
for fichier in listeFichiersAPI:
texteAAfficher = "(%s) %s" %( getattr( fichier, "date" ), getattr( fichier, "nom" ) )
if( fichier in self.listeTelechargements ):
listeFichiersPrecedementCoches.append( fichier )
cochee = 1
else:
cochee = 0
listeFichiersAAfficher.append( [ str( i ), texteAAfficher, cochee ] )
i+=1
choixFichiers = ( 0, [] )
while( choixFichiers[ 0 ] != 1 ):
choixFichiers = self.dialog.checklist( text = "Quels fichiers voulez-vous ajouter à la liste des téléchargements ?",
choices = listeFichiersAAfficher
)
if( choixFichiers[ 0 ] != 1 ):
for numeroFichier in choixFichiers[ 1 ]:
fichier = listeFichiersAPI[ int( numeroFichier ) ]
listeFichiersCoches.append( fichier )
for fichier in listeFichiersCoches:
if not ( fichier in listeFichiersPrecedementCoches ):
self.listeTelechargements.append( fichier )
for fichier in listeFichiersPrecedementCoches:
if not ( fichier in listeFichiersCoches ):
self.listeTelechargements.remove( fichier )
# On retourne au menu precedent
choixFichiers = ( 1, "" )
## Methode qui gere le gestionnaire de telechargement
def utlisationTelechargements( self ):
choix = ( 0, "" )
while( choix[ 0 ] != 1 ):
# On affiche le menu principal
choix = self.dialog.menu( text = "Gestionnaire de téléchargement" ,
choices = [ [ "Consulter", "Consulter la liste" ],
[ "Lancer", "Lancer les téléchargements" ]
]
)
# On lance la methode qui va bien
if( choix == ( 0, "Consulter" ) ):
if( len( self.listeTelechargements ) > 0 ):
texte = ""
for fichier in self.listeTelechargements:
texte += "(%s) %s\n" %( getattr( fichier, "date" ), getattr( fichier, "nom" ) )
else:
texte = "La liste des téléchargements est vide"
# On affiche la liste des fichiers a telecharger
self.dialog.msgbox( text = texte )
elif( choix == ( 0, "Lancer" ) ):
if( len( self.listeTelechargements ) > 0 ):
liste = []
for fichier in self.listeTelechargements:
lien = getattr( fichier , "lien" )
nomFichierSortie = getattr( fichier , "nomFichierSortie" )
if( nomFichierSortie == "" ): # Si le nom du fichier de sortie n'existe pas, on l'extrait de l'URL
nomFichierSortie = os.path.basename( lien )
liste.append( [ 0, lien, nomFichierSortie ] )
# On lance le telechargement
self.downloader.lancerTelechargement( liste )
self.dialog.msgbox( text = "Fin du téléchargement des fichiers" )
del self.listeTelechargements[ : ]
else:
self.dialog.msgbox( text = "Aucun fichier à télécharger" )
## Methode qui execute les actions necessaires avant de quitter le programme
def actionsAvantQuitter( self ):
print "Fermeture"
# On sauvegarde les options des plugins
self.api.fermeture()
# On sauvegarde l'historique
self.historique.sauverHistorique()
# On sauvegarde les options du logiciel
self.preferences.sauvegarderConfiguration() | Python |
# dialog.py --- A python interface to the Linux "dialog" utility
# Copyright (C) 2000 Robb Shecter, Sultanbek Tezadov
# Copyright (C) 2002, 2003, 2004 Florent Rougon
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""Python interface to dialog-like programs.
This module provides a Python interface to dialog-like programs such
as `dialog', `Xdialog' and `whiptail'.
It provides a Dialog class that retains some parameters such as the
program name and path as well as the values to pass as DIALOG*
environment variables to the chosen program.
For a quick start, you should look at the demo.py file that comes
with pythondialog. It demonstrates a simple use of each widget
offered by the Dialog class.
See the Dialog class documentation for general usage information,
list of available widgets and ways to pass options to dialog.
Notable exceptions
------------------
Here is the hierarchy of notable exceptions raised by this module:
error
ExecutableNotFound
BadPythonDialogUsage
PythonDialogSystemError
PythonDialogIOError
PythonDialogOSError
PythonDialogErrorBeforeExecInChildProcess
PythonDialogReModuleError
UnexpectedDialogOutput
DialogTerminatedBySignal
DialogError
UnableToCreateTemporaryDirectory
PythonDialogBug
ProbablyPythonBug
As you can see, every exception `exc' among them verifies:
issubclass(exc, error)
so if you don't need fine-grained error handling, simply catch
`error' (which will probably be accessible as dialog.error from your
program) and you should be safe.
"""
from __future__ import nested_scopes
import sys, os, tempfile, random, string, re, types
# Python < 2.3 compatibility
if sys.hexversion < 0x02030000:
# The assignments would work with Python >= 2.3 but then, pydoc
# shows them in the DATA section of the module...
True = 0 == 0
False = 0 == 1
# Exceptions raised by this module
#
# When adding, suppressing, renaming exceptions or changing their
# hierarchy, don't forget to update the module's docstring.
class error(Exception):
"""Base class for exceptions in pythondialog."""
def __init__(self, message=None):
self.message = message
def __str__(self):
return "<%s: %s>" % (self.__class__.__name__, self.message)
def complete_message(self):
if self.message:
return "%s: %s" % (self.ExceptionShortDescription, self.message)
else:
return "%s" % self.ExceptionShortDescription
ExceptionShortDescription = "pythondialog generic exception"
# For backward-compatibility
#
# Note: this exception was not documented (only the specific ones were), so
# the backward-compatibility binding could be removed relatively easily.
PythonDialogException = error
class ExecutableNotFound(error):
"""Exception raised when the dialog executable can't be found."""
ExceptionShortDescription = "Executable not found"
class PythonDialogBug(error):
"""Exception raised when pythondialog finds a bug in his own code."""
ExceptionShortDescription = "Bug in pythondialog"
# Yeah, the "Probably" makes it look a bit ugly, but:
# - this is more accurate
# - this avoids a potential clash with an eventual PythonBug built-in
# exception in the Python interpreter...
class ProbablyPythonBug(error):
"""Exception raised when pythondialog behaves in a way that seems to \
indicate a Python bug."""
ExceptionShortDescription = "Bug in python, probably"
class BadPythonDialogUsage(error):
"""Exception raised when pythondialog is used in an incorrect way."""
ExceptionShortDescription = "Invalid use of pythondialog"
class PythonDialogSystemError(error):
"""Exception raised when pythondialog cannot perform a "system \
operation" (e.g., a system call) that should work in "normal" situations.
This is a convenience exception: PythonDialogIOError, PythonDialogOSError
and PythonDialogErrorBeforeExecInChildProcess all derive from this
exception. As a consequence, watching for PythonDialogSystemError instead
of the aformentioned exceptions is enough if you don't need precise
details about these kinds of errors.
Don't confuse this exception with Python's builtin SystemError
exception.
"""
ExceptionShortDescription = "System error"
class PythonDialogIOError(PythonDialogSystemError):
"""Exception raised when pythondialog catches an IOError exception that \
should be passed to the calling program."""
ExceptionShortDescription = "IO error"
class PythonDialogOSError(PythonDialogSystemError):
"""Exception raised when pythondialog catches an OSError exception that \
should be passed to the calling program."""
ExceptionShortDescription = "OS error"
class PythonDialogErrorBeforeExecInChildProcess(PythonDialogSystemError):
"""Exception raised when an exception is caught in a child process \
before the exec sytem call (included).
This can happen in uncomfortable situations like when the system is out
of memory or when the maximum number of open file descriptors has been
reached. This can also happen if the dialog-like program was removed
(or if it is has been made non-executable) between the time we found it
with _find_in_path and the time the exec system call attempted to
execute it...
"""
ExceptionShortDescription = "Error in a child process before the exec " \
"system call"
class PythonDialogReModuleError(PythonDialogSystemError):
"""Exception raised when pythondialog catches a re.error exception."""
ExceptionShortDescription = "'re' module error"
class UnexpectedDialogOutput(error):
"""Exception raised when the dialog-like program returns something not \
expected by pythondialog."""
ExceptionShortDescription = "Unexpected dialog output"
class DialogTerminatedBySignal(error):
"""Exception raised when the dialog-like program is terminated by a \
signal."""
ExceptionShortDescription = "dialog-like terminated by a signal"
class DialogError(error):
"""Exception raised when the dialog-like program exits with the \
code indicating an error."""
ExceptionShortDescription = "dialog-like terminated due to an error"
class UnableToCreateTemporaryDirectory(error):
"""Exception raised when we cannot create a temporary directory."""
ExceptionShortDescription = "unable to create a temporary directory"
# Values accepted for checklists
try:
_on_rec = re.compile(r"on", re.IGNORECASE)
_off_rec = re.compile(r"off", re.IGNORECASE)
_calendar_date_rec = re.compile(
r"(?P<day>\d\d)/(?P<month>\d\d)/(?P<year>\d\d\d\d)$")
_timebox_time_rec = re.compile(
r"(?P<hour>\d\d):(?P<minute>\d\d):(?P<second>\d\d)$")
except re.error, v:
raise PythonDialogReModuleError(v)
# This dictionary allows us to write the dialog common options in a Pythonic
# way (e.g. dialog_instance.checklist(args, ..., title="Foo", no_shadow=1)).
#
# Options such as --separate-output should obviously not be set by the user
# since they affect the parsing of dialog's output:
_common_args_syntax = {
"aspect": lambda ratio: ("--aspect", str(ratio)),
"backtitle": lambda backtitle: ("--backtitle", backtitle),
"beep": lambda enable: _simple_option("--beep", enable),
"beep_after": lambda enable: _simple_option("--beep-after", enable),
# Warning: order = y, x!
"begin": lambda coords: ("--begin", str(coords[0]), str(coords[1])),
"cancel": lambda string: ("--cancel-label", string),
"clear": lambda enable: _simple_option("--clear", enable),
"cr_wrap": lambda enable: _simple_option("--cr-wrap", enable),
"create_rc": lambda file: ("--create-rc", file),
"defaultno": lambda enable: _simple_option("--defaultno", enable),
"default_item": lambda string: ("--default-item", string),
"help": lambda enable: _simple_option("--help", enable),
"help_button": lambda enable: _simple_option("--help-button", enable),
"help_label": lambda string: ("--help-label", string),
"ignore": lambda enable: _simple_option("--ignore", enable),
"item_help": lambda enable: _simple_option("--item-help", enable),
"max_input": lambda size: ("--max-input", str(size)),
"no_kill": lambda enable: _simple_option("--no-kill", enable),
"no_cancel": lambda enable: _simple_option("--no-cancel", enable),
"nocancel": lambda enable: _simple_option("--nocancel", enable),
"no_shadow": lambda enable: _simple_option("--no-shadow", enable),
"ok_label": lambda string: ("--ok-label", string),
"print_maxsize": lambda enable: _simple_option("--print-maxsize",
enable),
"print_size": lambda enable: _simple_option("--print-size", enable),
"print_version": lambda enable: _simple_option("--print-version",
enable),
"separate_output": lambda enable: _simple_option("--separate-output",
enable),
"separate_widget": lambda string: ("--separate-widget", string),
"shadow": lambda enable: _simple_option("--shadow", enable),
"size_err": lambda enable: _simple_option("--size-err", enable),
"sleep": lambda secs: ("--sleep", str(secs)),
"stderr": lambda enable: _simple_option("--stderr", enable),
"stdout": lambda enable: _simple_option("--stdout", enable),
"tab_correct": lambda enable: _simple_option("--tab-correct", enable),
"tab_len": lambda n: ("--tab-len", str(n)),
"timeout": lambda secs: ("--timeout", str(secs)),
"title": lambda title: ("--title", title),
"trim": lambda enable: _simple_option("--trim", enable),
"version": lambda enable: _simple_option("--version", enable)}
def _simple_option(option, enable):
"""Turn on or off the simplest dialog Common Options."""
if enable:
return (option,)
else:
# This will not add any argument to the command line
return ()
def _find_in_path(prog_name):
"""Search an executable in the PATH.
If PATH is not defined, the default path ":/bin:/usr/bin" is
used.
Return a path to the file or None if no readable and executable
file is found.
Notable exception: PythonDialogOSError
"""
try:
# Note that the leading empty component in the default value for PATH
# could lead to the returned path not being absolute.
PATH = os.getenv("PATH", ":/bin:/usr/bin") # see the execvp(3) man page
for dir in string.split(PATH, ":"):
file_path = os.path.join(dir, prog_name)
if os.path.isfile(file_path) \
and os.access(file_path, os.R_OK | os.X_OK):
return file_path
return None
except os.error, v:
raise PythonDialogOSError(v.strerror)
def _path_to_executable(f):
"""Find a path to an executable.
Find a path to an executable, using the same rules as the POSIX
exec*p functions (see execvp(3) for instance).
If `f' contains a '/', it is assumed to be a path and is simply
checked for read and write permissions; otherwise, it is looked
for according to the contents of the PATH environment variable,
which defaults to ":/bin:/usr/bin" if unset.
The returned path is not necessarily absolute.
Notable exceptions:
ExecutableNotFound
PythonDialogOSError
"""
try:
if '/' in f:
if os.path.isfile(f) and \
os.access(f, os.R_OK | os.X_OK):
res = f
else:
raise ExecutableNotFound("%s cannot be read and executed" % f)
else:
res = _find_in_path(f)
if res is None:
raise ExecutableNotFound(
"can't find the executable for the dialog-like "
"program")
except os.error, v:
raise PythonDialogOSError(v.strerror)
return res
def _to_onoff(val):
"""Convert boolean expressions to "on" or "off"
This function converts every non-zero integer as well as "on",
"ON", "On" and "oN" to "on" and converts 0, "off", "OFF", etc. to
"off".
Notable exceptions:
PythonDialogReModuleError
BadPythonDialogUsage
"""
if type(val) == types.IntType:
if val:
return "on"
else:
return "off"
elif type(val) == types.StringType:
try:
if _on_rec.match(val):
return "on"
elif _off_rec.match(val):
return "off"
except re.error, v:
raise PythonDialogReModuleError(v)
else:
raise BadPythonDialogUsage("invalid boolean value: %s" % val)
def _compute_common_args(dict):
"""Compute the list of arguments for dialog common options.
Compute a list of the command-line arguments to pass to dialog
from a keyword arguments dictionary for options listed as "common
options" in the manual page for dialog. These are the options
that are not tied to a particular widget.
This allows to specify these options in a pythonic way, such as:
d.checklist(<usual arguments for a checklist>,
title="...",
backtitle="...")
instead of having to pass them with strings like "--title foo" or
"--backtitle bar".
Notable exceptions: None
"""
args = []
for key in dict.keys():
args.extend(_common_args_syntax[key](dict[key]))
return args
def _create_temporary_directory():
"""Create a temporary directory (securely).
Return the directory path.
Notable exceptions:
- UnableToCreateTemporaryDirectory
- PythonDialogOSError
- exceptions raised by the tempfile module (which are
unfortunately not mentioned in its documentation, at
least in Python 2.3.3...)
"""
find_temporary_nb_attempts = 5
for i in range(find_temporary_nb_attempts):
try:
# Using something >= 2**31 causes an error in Python 2.2...
tmp_dir = os.path.join(tempfile.gettempdir(),
"%s-%u" \
% ("pythondialog",
random.randint(0, 2**30-1)))
except os.error, v:
raise PythonDialogOSError(v.strerror)
try:
os.mkdir(tmp_dir, 0700)
except os.error:
continue
else:
break
else:
raise UnableToCreateTemporaryDirectory(
"somebody may be trying to attack us")
return tmp_dir
# DIALOG_OK, DIALOG_CANCEL, etc. are environment variables controlling
# dialog's exit status in the corresponding situation.
#
# Note:
# - 127 must not be used for any of the DIALOG_* values. It is used
# when a failure occurs in the child process before it exec()s
# dialog (where "before" includes a potential exec() failure).
# - 126 is also used (although in presumably rare situations).
_dialog_exit_status_vars = { "OK": 0,
"CANCEL": 1,
"ESC": 2,
"ERROR": 3,
"EXTRA": 4,
"HELP": 5 }
# Main class of the module
class Dialog:
"""Class providing bindings for dialog-compatible programs.
This class allows you to invoke dialog or a compatible program in
a pythonic way to build quicky and easily simple but nice text
interfaces.
An application typically creates one instance of the Dialog class
and uses it for all its widgets, but it is possible to use
concurrently several instances of this class with different
parameters (such as the background title) if you have the need
for this.
The exit code (exit status) returned by dialog is to be
compared with the DIALOG_OK, DIALOG_CANCEL, DIALOG_ESC,
DIALOG_ERROR, DIALOG_EXTRA and DIALOG_HELP attributes of the
Dialog instance (they are integers).
Note: although this class does all it can to allow the caller to
differentiate between the various reasons that caused a
dialog box to be closed, its backend, dialog 0.9a-20020309a
for my tests, doesn't always return DIALOG_ESC when the
user presses the ESC key, but often returns DIALOG_ERROR
instead. The exit codes returned by the corresponding
Dialog methods are of course just as wrong in these cases.
You've been warned.
Public methods of the Dialog class (mainly widgets)
---------------------------------------------------
The Dialog class has the following methods:
add_persistent_args
calendar
checklist
fselect
gauge_start
gauge_update
gauge_stop
infobox
inputbox
menu
msgbox
passwordbox
radiolist
scrollbox
tailbox
textbox
timebox
yesno
clear (obsolete)
setBackgroundTitle (obsolete)
Passing dialog "Common Options"
-------------------------------
Every widget method has a **kwargs argument allowing you to pass
dialog so-called Common Options (see the dialog(1) manual page)
to dialog for this widget call. For instance, if `d' is a Dialog
instance, you can write:
d.checklist(args, ..., title="A Great Title", no_shadow=1)
The no_shadow option is worth looking at:
1. It is an option that takes no argument as far as dialog is
concerned (unlike the "--title" option, for instance). When
you list it as a keyword argument, the option is really
passed to dialog only if the value you gave it evaluates to
true, e.g. "no_shadow=1" will cause "--no-shadow" to be
passed to dialog whereas "no_shadow=0" will cause this
option not to be passed to dialog at all.
2. It is an option that has a hyphen (-) in its name, which you
must change into an underscore (_) to pass it as a Python
keyword argument. Therefore, "--no-shadow" is passed by
giving a "no_shadow=1" keyword argument to a Dialog method
(the leading two dashes are also consistently removed).
Exceptions
----------
Please refer to the specific methods' docstrings or simply to the
module's docstring for a list of all exceptions that might be
raised by this class' methods.
"""
def __init__(self, dialog="dialog", DIALOGRC=None, compat="dialog",
use_stdout=None):
"""Constructor for Dialog instances.
dialog -- name of (or path to) the dialog-like program to
use; if it contains a '/', it is assumed to be a
path and is used as is; otherwise, it is looked
for according to the contents of the PATH
environment variable, which defaults to
":/bin:/usr/bin" if unset.
DIALOGRC -- string to pass to the dialog-like program as the
DIALOGRC environment variable, or None if no
modification to the environment regarding this
variable should be done in the call to the
dialog-like program
compat -- compatibility mode (see below)
The officially supported dialog-like program in pythondialog
is the well-known dialog program written in C, based on the
ncurses library. It is also known as cdialog and its home
page is currently (2004-03-15) located at:
http://dickey.his.com/dialog/dialog.html
If you want to use a different program such as Xdialog, you
should indicate the executable file name with the `dialog'
argument *and* the compatibility type that you think it
conforms to with the `compat' argument. Currently, `compat'
can be either "dialog" (for dialog; this is the default) or
"Xdialog" (for, well, Xdialog).
The `compat' argument allows me to cope with minor
differences in behaviour between the various programs
implementing the dialog interface (not the text or graphical
interface, I mean the "API"). However, having to support
various APIs simultaneously is a bit ugly and I would really
prefer you to report bugs to the relevant maintainers when
you find incompatibilities with dialog. This is for the
benefit of pretty much everyone that relies on the dialog
interface.
Notable exceptions:
ExecutableNotFound
PythonDialogOSError
"""
# DIALOGRC differs from the other DIALOG* variables in that:
# 1. It should be a string if not None
# 2. We may very well want it to be unset
if DIALOGRC is not None:
self.DIALOGRC = DIALOGRC
# After reflexion, I think DIALOG_OK, DIALOG_CANCEL, etc.
# should never have been instance attributes (I cannot see a
# reason why the user would want to change their values or
# even read them), but it is a bit late, now. So, we set them
# based on the (global) _dialog_exit_status_vars.keys.
for var in _dialog_exit_status_vars.keys():
varname = "DIALOG_" + var
setattr(self, varname, _dialog_exit_status_vars[var])
self._dialog_prg = _path_to_executable(dialog)
self.compat = compat
self.dialog_persistent_arglist = []
# Use stderr or stdout?
if self.compat == "Xdialog":
# Default to stdout if Xdialog
self.use_stdout = True
else:
self.use_stdout = False
if use_stdout != None:
# Allow explicit setting
self.use_stdout = use_stdout
if self.use_stdout:
self.add_persistent_args(["--stdout"])
def add_persistent_args(self, arglist):
self.dialog_persistent_arglist.extend(arglist)
# For compatibility with the old dialog...
def setBackgroundTitle(self, text):
"""Set the background title for dialog.
This method is obsolete. Please remove calls to it from your
programs.
"""
self.add_persistent_args(("--backtitle", text))
def _call_program(self, redirect_child_stdin, cmdargs, **kwargs):
"""Do the actual work of invoking the dialog-like program.
Communication with the dialog-like program is performed
through one or two pipes, depending on
`redirect_child_stdin'. There is always one pipe that is
created to allow the parent process to read what dialog
writes on its standard error stream.
If `redirect_child_stdin' is True, an additional pipe is
created whose reading end is connected to dialog's standard
input. This is used by the gauge widget to feed data to
dialog.
Beware when interpreting the return value: the length of the
returned tuple depends on `redirect_child_stdin'.
Notable exception: PythonDialogOSError (if pipe() or close()
system calls fail...)
"""
# We want to define DIALOG_OK, DIALOG_CANCEL, etc. in the
# environment of the child process so that we know (and
# even control) the possible dialog exit statuses.
new_environ = {}
new_environ.update(os.environ)
for var in _dialog_exit_status_vars:
varname = "DIALOG_" + var
new_environ[varname] = str(getattr(self, varname))
if hasattr(self, "DIALOGRC"):
new_environ["DIALOGRC"] = self.DIALOGRC
# Create:
# - a pipe so that the parent process can read dialog's output on
# stdout/stderr
# - a pipe so that the parent process can feed data to dialog's
# stdin (this is needed for the gauge widget) if
# redirect_child_stdin is True
try:
# rfd = File Descriptor for Reading
# wfd = File Descriptor for Writing
(child_rfd, child_wfd) = os.pipe()
if redirect_child_stdin:
(child_stdin_rfd, child_stdin_wfd) = os.pipe()
except os.error, v:
raise PythonDialogOSError(v.strerror)
child_pid = os.fork()
if child_pid == 0:
# We are in the child process. We MUST NOT raise any exception.
try:
# The child process doesn't need these file descriptors
os.close(child_rfd)
if redirect_child_stdin:
os.close(child_stdin_wfd)
# We want:
# - dialog's output on stderr/stdout to go to child_wfd
# - data written to child_stdin_wfd to go to dialog's stdin
# if redirect_child_stdin is True
if self.use_stdout:
os.dup2(child_wfd, 1)
else:
os.dup2(child_wfd, 2)
if redirect_child_stdin:
os.dup2(child_stdin_rfd, 0)
arglist = [self._dialog_prg] + \
self.dialog_persistent_arglist + \
_compute_common_args(kwargs) + \
cmdargs
# Insert here the contents of the DEBUGGING file if you want
# to obtain a handy string of the complete command line with
# arguments quoted for the shell and environment variables
# set.
os.execve(self._dialog_prg, arglist, new_environ)
except:
os._exit(127)
# Should not happen unless there is a bug in Python
os._exit(126)
# We are in the father process.
#
# It is essential to close child_wfd, otherwise we will never
# see EOF while reading on child_rfd and the parent process
# will block forever on the read() call.
# [ after the fork(), the "reference count" of child_wfd from
# the operating system's point of view is 2; after the child exits,
# it is 1 until the father closes it itself; then it is 0 and a read
# on child_rfd encounters EOF once all the remaining data in
# the pipe has been read. ]
try:
os.close(child_wfd)
if redirect_child_stdin:
os.close(child_stdin_rfd)
return (child_pid, child_rfd, child_stdin_wfd)
else:
return (child_pid, child_rfd)
except os.error, v:
raise PythonDialogOSError(v.strerror)
def _wait_for_program_termination(self, child_pid, child_rfd):
"""Wait for a dialog-like process to terminate.
This function waits for the specified process to terminate,
raises the appropriate exceptions in case of abnormal
termination and returns the exit status and standard error
output of the process as a tuple: (exit_code, stderr_string).
`child_rfd' must be the file descriptor for the
reading end of the pipe created by self._call_program()
whose writing end was connected by self._call_program() to
the child process's standard error.
This function reads the process's output on standard error
from `child_rfd' and closes this file descriptor once
this is done.
Notable exceptions:
DialogTerminatedBySignal
DialogError
PythonDialogErrorBeforeExecInChildProcess
PythonDialogIOError
PythonDialogBug
ProbablyPythonBug
"""
exit_info = os.waitpid(child_pid, 0)[1]
if os.WIFEXITED(exit_info):
exit_code = os.WEXITSTATUS(exit_info)
# As we wait()ed for the child process to terminate, there is no
# need to call os.WIFSTOPPED()
elif os.WIFSIGNALED(exit_info):
raise DialogTerminatedBySignal("the dialog-like program was "
"terminated by signal %u" %
os.WTERMSIG(exit_info))
else:
raise PythonDialogBug("please report this bug to the "
"pythondialog maintainers")
if exit_code == self.DIALOG_ERROR:
raise DialogError("the dialog-like program exited with "
"code %d (was passed to it as the DIALOG_ERROR "
"environment variable)" % exit_code)
elif exit_code == 127:
raise PythonDialogErrorBeforeExecInChildProcess(
"perhaps the dialog-like program could not be executed; "
"perhaps the system is out of memory; perhaps the maximum "
"number of open file descriptors has been reached")
elif exit_code == 126:
raise ProbablyPythonBug(
"a child process returned with exit status 126; this might "
"be the exit status of the dialog-like program, for some "
"unknown reason (-> probably a bug in the dialog-like "
"program); otherwise, we have probably found a python bug")
# We might want to check here whether exit_code is really one of
# DIALOG_OK, DIALOG_CANCEL, etc. However, I prefer not doing it
# because it would break pythondialog for no strong reason when new
# exit codes are added to the dialog-like program.
#
# As it is now, if such a thing happens, the program using
# pythondialog may receive an exit_code it doesn't know about. OK, the
# programmer just has to tell the pythondialog maintainer about it and
# can temporarily set the appropriate DIALOG_* environment variable if
# he wants and assign the corresponding value to the Dialog instance's
# DIALOG_FOO attribute from his program. He doesn't even need to use a
# patched pythondialog before he upgrades to a version that knows
# about the new exit codes.
#
# The bad thing that might happen is a new DIALOG_FOO exit code being
# the same by default as one of those we chose for the other exit
# codes already known by pythondialog. But in this situation, the
# check that is being discussed wouldn't help at all.
# Read dialog's output on its stderr
try:
child_output = os.fdopen(child_rfd, "rb").read()
# Now, since the file object has no reference anymore, the
# standard IO stream behind it will be closed, causing the
# end of the the pipe we used to read dialog's output on its
# stderr to be closed (this is important, otherwise invoking
# dialog enough times will eventually exhaust the maximum number
# of open file descriptors).
except IOError, v:
raise PythonDialogIOError(v)
return (exit_code, child_output)
def _perform(self, cmdargs, **kwargs):
"""Perform a complete dialog-like program invocation.
This function invokes the dialog-like program, waits for its
termination and returns its exit status and whatever it wrote
on its standard error stream.
Notable exceptions:
any exception raised by self._call_program() or
self._wait_for_program_termination()
"""
(child_pid, child_rfd) = \
self._call_program(False, *(cmdargs,), **kwargs)
(exit_code, output) = \
self._wait_for_program_termination(child_pid,
child_rfd)
return (exit_code, output)
def _strip_xdialog_newline(self, output):
"""Remove trailing newline (if any), if using Xdialog"""
if self.compat == "Xdialog" and output.endswith("\n"):
output = output[:-1]
return output
# This is for compatibility with the old dialog.py
def _perform_no_options(self, cmd):
"""Call dialog without passing any more options."""
return os.system(self._dialog_prg + ' ' + cmd)
# For compatibility with the old dialog.py
def clear(self):
"""Clear the screen. Equivalent to the dialog --clear option.
This method is obsolete. Please remove calls to it from your
programs.
"""
self._perform_no_options('--clear')
def calendar(self, text, height=6, width=0, day=0, month=0, year=0,
**kwargs):
"""Display a calendar dialog box.
text -- text to display in the box
height -- height of the box (minus the calendar height)
width -- width of the box
day -- inititial day highlighted
month -- inititial month displayed
year -- inititial year selected (0 causes the current date
to be used as the initial date)
A calendar box displays month, day and year in separately
adjustable windows. If the values for day, month or year are
missing or negative, the current date's corresponding values
are used. You can increment or decrement any of those using
the left, up, right and down arrows. Use tab or backtab to
move between windows. If the year is given as zero, the
current date is used as an initial value.
Return a tuple of the form (code, date) where `code' is the
exit status (an integer) of the dialog-like program and
`date' is a list of the form [day, month, year] (where `day',
`month' and `year' are integers corresponding to the date
chosen by the user) if the box was closed with OK, or None if
it was closed with the Cancel button.
Notable exceptions:
- any exception raised by self._perform()
- UnexpectedDialogOutput
- PythonDialogReModuleError
"""
(code, output) = self._perform(
*(["--calendar", text, str(height), str(width), str(day),
str(month), str(year)],),
**kwargs)
if code == self.DIALOG_OK:
try:
mo = _calendar_date_rec.match(output)
except re.error, v:
raise PythonDialogReModuleError(v)
if mo is None:
raise UnexpectedDialogOutput(
"the dialog-like program returned the following "
"unexpected date with the calendar box: %s" % output)
date = map(int, mo.group("day", "month", "year"))
else:
date = None
return (code, date)
def checklist(self, text, height=15, width=54, list_height=7,
choices=[], **kwargs):
"""Display a checklist box.
text -- text to display in the box
height -- height of the box
width -- width of the box
list_height -- number of entries displayed in the box (which
can be scrolled) at a given time
choices -- a list of tuples (tag, item, status) where
`status' specifies the initial on/off state of
each entry; can be 0 or 1 (integers, 1 meaning
checked, i.e. "on"), or "on", "off" or any
uppercase variant of these two strings.
Return a tuple of the form (code, [tag, ...]) with the tags
for the entries that were selected by the user. `code' is the
exit status of the dialog-like program.
If the user exits with ESC or CANCEL, the returned tag list
is empty.
Notable exceptions:
any exception raised by self._perform() or _to_onoff()
"""
cmd = ["--checklist", text, str(height), str(width), str(list_height)]
for t in choices:
cmd.extend(((t[0], t[1], _to_onoff(t[2]))))
# The dialog output cannot be parsed reliably (at least in dialog
# 0.9b-20040301) without --separate-output (because double quotes in
# tags are escaped with backslashes, but backslashes are not
# themselves escaped and you have a problem when a tag ends with a
# backslash--the output makes you think you've encountered an embedded
# double-quote).
kwargs["separate_output"] = True
(code, output) = self._perform(*(cmd,), **kwargs)
# Since we used --separate-output, the tags are separated by a newline
# in the output. There is also a final newline after the last tag.
if output:
return (code, string.split(output, '\n')[:-1])
else: # empty selection
return (code, [])
def fselect(self, filepath, height, width, **kwargs):
"""Display a file selection dialog box.
filepath -- initial file path
height -- height of the box
width -- width of the box
The file-selection dialog displays a text-entry window in
which you can type a filename (or directory), and above that
two windows with directory names and filenames.
Here, filepath can be a file path in which case the file and
directory windows will display the contents of the path and
the text-entry window will contain the preselected filename.
Use tab or arrow keys to move between the windows. Within the
directory or filename windows, use the up/down arrow keys to
scroll the current selection. Use the space-bar to copy the
current selection into the text-entry window.
Typing any printable character switches focus to the
text-entry window, entering that character as well as
scrolling the directory and filename windows to the closest
match.
Use a carriage return or the "OK" button to accept the
current value in the text-entry window, or the "Cancel"
button to cancel.
Return a tuple of the form (code, path) where `code' is the
exit status (an integer) of the dialog-like program and
`path' is the path chosen by the user (whose last element may
be a directory or a file).
Notable exceptions:
any exception raised by self._perform()
"""
(code, output) = self._perform(
*(["--fselect", filepath, str(height), str(width)],),
**kwargs)
output = self._strip_xdialog_newline(output)
return (code, output)
def gauge_start(self, text="", height=8, width=54, percent=0, **kwargs):
"""Display gauge box.
text -- text to display in the box
height -- height of the box
width -- width of the box
percent -- initial percentage shown in the meter
A gauge box displays a meter along the bottom of the box. The
meter indicates a percentage.
This function starts the dialog-like program telling it to
display a gauge box with a text in it and an initial
percentage in the meter.
Return value: undefined.
Gauge typical usage
-------------------
Gauge typical usage (assuming that `d' is an instance of the
Dialog class) looks like this:
d.gauge_start()
# do something
d.gauge_update(10) # 10% of the whole task is done
# ...
d.gauge_update(100, "any text here") # work is done
exit_code = d.gauge_stop() # cleanup actions
Notable exceptions:
- any exception raised by self._call_program()
- PythonDialogOSError
"""
(child_pid, child_rfd, child_stdin_wfd) = self._call_program(
True,
*(["--gauge", text, str(height), str(width), str(percent)],),
**kwargs)
try:
self._gauge_process = {
"pid": child_pid,
"stdin": os.fdopen(child_stdin_wfd, "wb"),
"child_rfd": child_rfd
}
except os.error, v:
raise PythonDialogOSError(v.strerror)
def gauge_update(self, percent, text="", update_text=0):
"""Update a running gauge box.
percent -- new percentage to show in the gauge meter
text -- new text to optionally display in the box
update-text -- boolean indicating whether to update the
text in the box
This function updates the percentage shown by the meter of a
running gauge box (meaning `gauge_start' must have been
called previously). If update_text is true (for instance, 1),
the text displayed in the box is also updated.
See the `gauge_start' function's documentation for
information about how to use a gauge.
Return value: undefined.
Notable exception: PythonDialogIOError can be raised if there
is an I/O error while writing to the pipe
used to talk to the dialog-like program.
"""
if update_text:
gauge_data = "%d\nXXX\n%s\nXXX\n" % (percent, text)
else:
gauge_data = "%d\n" % percent
try:
self._gauge_process["stdin"].write(gauge_data)
self._gauge_process["stdin"].flush()
except IOError, v:
raise PythonDialogIOError(v)
# For "compatibility" with the old dialog.py...
gauge_iterate = gauge_update
def gauge_stop(self):
"""Terminate a running gauge.
This function performs the appropriate cleanup actions to
terminate a running gauge (started with `gauge_start').
See the `gauge_start' function's documentation for
information about how to use a gauge.
Return value: undefined.
Notable exceptions:
- any exception raised by
self._wait_for_program_termination()
- PythonDialogIOError can be raised if closing the pipe
used to talk to the dialog-like program fails.
"""
p = self._gauge_process
# Close the pipe that we are using to feed dialog's stdin
try:
p["stdin"].close()
except IOError, v:
raise PythonDialogIOError(v)
exit_code = \
self._wait_for_program_termination(p["pid"],
p["child_rfd"])[0]
return exit_code
def infobox(self, text, height=10, width=30, **kwargs):
"""Display an information dialog box.
text -- text to display in the box
height -- height of the box
width -- width of the box
An info box is basically a message box. However, in this
case, dialog will exit immediately after displaying the
message to the user. The screen is not cleared when dialog
exits, so that the message will remain on the screen until
the calling shell script clears it later. This is useful
when you want to inform the user that some operations are
carrying on that may require some time to finish.
Return the exit status (an integer) of the dialog-like
program.
Notable exceptions:
any exception raised by self._perform()
"""
return self._perform(
*(["--infobox", text, str(height), str(width)],),
**kwargs)[0]
def inputbox(self, text, height=10, width=30, init='', **kwargs):
"""Display an input dialog box.
text -- text to display in the box
height -- height of the box
width -- width of the box
init -- default input string
An input box is useful when you want to ask questions that
require the user to input a string as the answer. If init is
supplied it is used to initialize the input string. When
entering the string, the BACKSPACE key can be used to
correct typing errors. If the input string is longer than
can fit in the dialog box, the input field will be scrolled.
Return a tuple of the form (code, string) where `code' is the
exit status of the dialog-like program and `string' is the
string entered by the user.
Notable exceptions:
any exception raised by self._perform()
"""
(code, tag) = self._perform(
*(["--inputbox", text, str(height), str(width), init],),
**kwargs)
tag = self._strip_xdialog_newline(tag)
return (code, tag)
def menu(self, text, height=15, width=54, menu_height=7, choices=[],
**kwargs):
"""Display a menu dialog box.
text -- text to display in the box
height -- height of the box
width -- width of the box
menu_height -- number of entries displayed in the box (which
can be scrolled) at a given time
choices -- a sequence of (tag, item) or (tag, item, help)
tuples (the meaning of each `tag', `item' and
`help' is explained below)
Overview
--------
As its name suggests, a menu box is a dialog box that can be
used to present a list of choices in the form of a menu for
the user to choose. Choices are displayed in the order given.
Each menu entry consists of a `tag' string and an `item'
string. The tag gives the entry a name to distinguish it from
the other entries in the menu. The item is a short
description of the option that the entry represents.
The user can move between the menu entries by pressing the
UP/DOWN keys, the first letter of the tag as a hot-key, or
the number keys 1-9. There are menu-height entries displayed
in the menu at one time, but the menu will be scrolled if
there are more entries than that.
Providing on-line help facilities
---------------------------------
If this function is called with item_help=1 (keyword
argument), the option --item-help is passed to dialog and the
tuples contained in `choices' must contain 3 elements each :
(tag, item, help). The help string for the highlighted item
is displayed in the bottom line of the screen and updated as
the user highlights other items.
If item_help=0 or if this keyword argument is not passed to
this function, the tuples contained in `choices' must contain
2 elements each : (tag, item).
If this function is called with help_button=1, it must also
be called with item_help=1 (this is a limitation of dialog),
therefore the tuples contained in `choices' must contain 3
elements each as explained in the previous paragraphs. This
will cause a Help button to be added to the right of the
Cancel button (by passing --help-button to dialog).
Return value
------------
Return a tuple of the form (exit_info, string).
`exit_info' is either:
- an integer, being the the exit status of the dialog-like
program
- or the string "help", meaning that help_button=1 was
passed and that the user chose the Help button instead of
OK or Cancel.
The meaning of `string' depends on the value of exit_info:
- if `exit_info' is 0, `string' is the tag chosen by the
user
- if `exit_info' is "help", `string' is the `help' string
from the `choices' argument corresponding to the item
that was highlighted when the user chose the Help button
- otherwise (the user chose Cancel or pressed Esc, or there
was a dialog error), the value of `string' is undefined.
Notable exceptions:
any exception raised by self._perform()
"""
cmd = ["--menu", text, str(height), str(width), str(menu_height)]
for t in choices:
cmd.extend(t)
(code, output) = self._perform(*(cmd,), **kwargs)
output = self._strip_xdialog_newline(output)
if "help_button" in kwargs.keys() and output.startswith("HELP "):
return ("help", output[5:])
else:
return (code, output)
def msgbox(self, text, height=10, width=30, **kwargs):
"""Display a message dialog box.
text -- text to display in the box
height -- height of the box
width -- width of the box
A message box is very similar to a yes/no box. The only
difference between a message box and a yes/no box is that a
message box has only a single OK button. You can use this
dialog box to display any message you like. After reading
the message, the user can press the ENTER key so that dialog
will exit and the calling program can continue its
operation.
Return the exit status (an integer) of the dialog-like
program.
Notable exceptions:
any exception raised by self._perform()
"""
return self._perform(
*(["--msgbox", text, str(height), str(width)],),
**kwargs)[0]
def passwordbox(self, text, height=10, width=60, init='', **kwargs):
"""Display an password input dialog box.
text -- text to display in the box
height -- height of the box
width -- width of the box
init -- default input password
A password box is similar to an input box, except that the
text the user enters is not displayed. This is useful when
prompting for passwords or other sensitive information. Be
aware that if anything is passed in "init", it will be
visible in the system's process table to casual snoopers.
Also, it is very confusing to the user to provide them with a
default password they cannot see. For these reasons, using
"init" is highly discouraged.
Return a tuple of the form (code, password) where `code' is
the exit status of the dialog-like program and `password' is
the password entered by the user.
Notable exceptions:
any exception raised by self._perform()
"""
(code, password) = self._perform(
*(["--passwordbox", text, str(height), str(width), init],),
**kwargs)
password = self._strip_xdialog_newline(password)
return (code, password)
def radiolist(self, text, height=15, width=54, list_height=7,
choices=[], **kwargs):
"""Display a radiolist box.
text -- text to display in the box
height -- height of the box
width -- width of the box
list_height -- number of entries displayed in the box (which
can be scrolled) at a given time
choices -- a list of tuples (tag, item, status) where
`status' specifies the initial on/off state
each entry; can be 0 or 1 (integers, 1 meaning
checked, i.e. "on"), or "on", "off" or any
uppercase variant of these two strings.
No more than one entry should be set to on.
A radiolist box is similar to a menu box. The main difference
is that you can indicate which entry is initially selected,
by setting its status to on.
Return a tuple of the form (code, tag) with the tag for the
entry that was chosen by the user. `code' is the exit status
of the dialog-like program.
If the user exits with ESC or CANCEL, or if all entries were
initially set to off and not altered before the user chose
OK, the returned tag is the empty string.
Notable exceptions:
any exception raised by self._perform() or _to_onoff()
"""
cmd = ["--radiolist", text, str(height), str(width), str(list_height)]
for t in choices:
cmd.extend(((t[0], t[1], _to_onoff(t[2]))))
(code, tag) = self._perform(*(cmd,), **kwargs)
tag = self._strip_xdialog_newline(tag)
return (code, tag)
def scrollbox(self, text, height=20, width=78, **kwargs):
"""Display a string in a scrollable box.
text -- text to display in the box
height -- height of the box
width -- width of the box
This method is a layer on top of textbox. The textbox option
in dialog allows to display file contents only. This method
allows you to display any text in a scrollable box. This is
simply done by creating a temporary file, calling textbox and
deleting the temporary file afterwards.
Return the dialog-like program's exit status.
Notable exceptions:
- UnableToCreateTemporaryDirectory
- PythonDialogIOError
- PythonDialogOSError
- exceptions raised by the tempfile module (which are
unfortunately not mentioned in its documentation, at
least in Python 2.3.3...)
"""
# In Python < 2.3, the standard library does not have
# tempfile.mkstemp(), and unfortunately, tempfile.mktemp() is
# insecure. So, I create a non-world-writable temporary directory and
# store the temporary file in this directory.
try:
# We want to ensure that f is already bound in the local
# scope when the finally clause (see below) is executed
f = 0
tmp_dir = _create_temporary_directory()
# If we are here, tmp_dir *is* created (no exception was raised),
# so chances are great that os.rmdir(tmp_dir) will succeed (as
# long as tmp_dir is empty).
#
# Don't move the _create_temporary_directory() call inside the
# following try statement, otherwise the user will always see a
# PythonDialogOSError instead of an
# UnableToCreateTemporaryDirectory because whenever
# UnableToCreateTemporaryDirectory is raised, the subsequent
# os.rmdir(tmp_dir) is bound to fail.
try:
fName = os.path.join(tmp_dir, "text")
# No race condition as with the deprecated tempfile.mktemp()
# since tmp_dir is not world-writable.
f = open(fName, "wb")
f.write(text)
f.close()
# Ask for an empty title unless otherwise specified
if not "title" in kwargs.keys():
kwargs["title"] = ""
return self._perform(
*(["--textbox", fName, str(height), str(width)],),
**kwargs)[0]
finally:
if type(f) == types.FileType:
f.close() # Safe, even several times
os.unlink(fName)
os.rmdir(tmp_dir)
except os.error, v:
raise PythonDialogOSError(v.strerror)
except IOError, v:
raise PythonDialogIOError(v)
def tailbox(self, filename, height=20, width=60, **kwargs):
"""Display the contents of a file in a dialog box, as in "tail -f".
filename -- name of the file whose contents is to be
displayed in the box
height -- height of the box
width -- width of the box
Display the contents of the specified file, updating the
dialog box whenever the file grows, as with the "tail -f"
command.
Return the exit status (an integer) of the dialog-like
program.
Notable exceptions:
any exception raised by self._perform()
"""
return self._perform(
*(["--tailbox", filename, str(height), str(width)],),
**kwargs)[0]
# No tailboxbg widget, at least for now.
def textbox(self, filename, height=20, width=60, **kwargs):
"""Display the contents of a file in a dialog box.
filename -- name of the file whose contents is to be
displayed in the box
height -- height of the box
width -- width of the box
A text box lets you display the contents of a text file in a
dialog box. It is like a simple text file viewer. The user
can move through the file by using the UP/DOWN, PGUP/PGDN
and HOME/END keys available on most keyboards. If the lines
are too long to be displayed in the box, the LEFT/RIGHT keys
can be used to scroll the text region horizontally. For more
convenience, forward and backward searching functions are
also provided.
Return the exit status (an integer) of the dialog-like
program.
Notable exceptions:
any exception raised by self._perform()
"""
# This is for backward compatibility... not that it is
# stupid, but I prefer explicit programming.
if not "title" in kwargs.keys():
kwargs["title"] = filename
return self._perform(
*(["--textbox", filename, str(height), str(width)],),
**kwargs)[0]
def timebox(self, text, height=3, width=30, hour=-1, minute=-1,
second=-1, **kwargs):
"""Display a time dialog box.
text -- text to display in the box
height -- height of the box
width -- width of the box
hour -- inititial hour selected
minute -- inititial minute selected
second -- inititial second selected
A dialog is displayed which allows you to select hour, minute
and second. If the values for hour, minute or second are
negative (or not explicitely provided, as they default to
-1), the current time's corresponding values are used. You
can increment or decrement any of those using the left-, up-,
right- and down-arrows. Use tab or backtab to move between
windows.
Return a tuple of the form (code, time) where `code' is the
exit status (an integer) of the dialog-like program and
`time' is a list of the form [hour, minute, second] (where
`hour', `minute' and `second' are integers corresponding to
the time chosen by the user) if the box was closed with OK,
or None if it was closed with the Cancel button.
Notable exceptions:
- any exception raised by self._perform()
- PythonDialogReModuleError
- UnexpectedDialogOutput
"""
(code, output) = self._perform(
*(["--timebox", text, str(height), str(width),
str(hour), str(minute), str(second)],),
**kwargs)
if code == self.DIALOG_OK:
try:
mo = _timebox_time_rec.match(output)
if mo is None:
raise UnexpectedDialogOutput(
"the dialog-like program returned the following "
"unexpected time with the --timebox option: %s" % output)
time = map(int, mo.group("hour", "minute", "second"))
except re.error, v:
raise PythonDialogReModuleError(v)
else:
time = None
return (code, time)
def yesno(self, text, height=10, width=30, **kwargs):
"""Display a yes/no dialog box.
text -- text to display in the box
height -- height of the box
width -- width of the box
A yes/no dialog box of size `height' rows by `width' columns
will be displayed. The string specified by `text' is
displayed inside the dialog box. If this string is too long
to fit in one line, it will be automatically divided into
multiple lines at appropriate places. The text string can
also contain the sub-string "\\n" or newline characters to
control line breaking explicitly. This dialog box is useful
for asking questions that require the user to answer either
yes or no. The dialog box has a Yes button and a No button,
in which the user can switch between by pressing the TAB
key.
Return the exit status (an integer) of the dialog-like
program.
Notable exceptions:
any exception raised by self._perform()
"""
return self._perform(
*(["--yesno", text, str(height), str(width)],),
**kwargs)[0]
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import cPickle as pickle
import os
import Constantes
from Fichier import Fichier
import logging
logger = logging.getLogger( __name__ )
##########
# 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.chargerHistorique()
## Destructeur
def __del__( self ):
self.sauverHistorique()
## Charge l'historique existant
def chargerHistorique( self ):
if os.path.exists( Constantes.FICHIER_HISTORIQUE_TVD ): # Charge le fichier s'il existe
logger.info( "chargerHistorique : chargement de l'historique" )
with open( Constantes.FICHIER_HISTORIQUE_TVD, "r" ) as fichier:
self.historique = pickle.load( fichier )
else: # Sinon, historique vide
logger.info( "chargerHistorique : fichier historique non trouve ; creation" )
self.historique = {}
## Ajoute un fichier a l'historique
# @param nouveauFichier Fichier a ajouter a l'historique
def ajouterHistorique( self, nouveauFichier ):
if( isinstance( nouveauFichier, Fichier ) ):
date = nouveauFichier.date
if( self.historique.has_key( date ) ):
self.historique[ date ].append( nouveauFichier )
else:
self.historique[ date ] = [ nouveauFichier ]
## Sauvegarde l'historique
def sauverHistorique( self ):
# On enregistre l'historique
with open( Constantes.FICHIER_HISTORIQUE_TVD, "w" ) as fichier:
logger.info( "sauverHistorique : sauvegarde de l'historique" )
pickle.dump( self.historique, fichier )
## 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 = fichier.date
if( self.historique.has_key( date ) ):
return fichier in self.historique[ date ]
else:
return False
else:
return False
## Nettoie l'historique
# Supprime les entrees les plus vieilles de l'historique
def nettoieHistorique( self ):
logger.info( "nettoieHistorique : suppression des vieilles reference de l'historique" )
| 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" )
#TODO
FICHIER_HISTORIQUE_TVD = ""
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import datetime
import os.path
import lib
import logging
logger = logging.getLogger( __name__ )
##########
# Classe #
##########
## Classe qui contient les informations d'un fichier
class Fichier(object):
## Contructeur
# @param nom Le nom du fichier (tel qu'affiché à l'utilisateur)
# @param date La date du fichier
# @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 = datetime.date.today(), lien = "", nomFichierSortie = "", urlImage = "", descriptif = "" ):
self.nom = lib.html.supprimeBalisesHTML( nom )
self.date = date
self.lien = lien
if( nomFichierSortie == "" ):
self.nomFichierSortie = lib.fichierDossier.chaineToNomFichier( os.path.basename( self.lien ) )
else:
self.nomFichierSortie = lib.fichierDossier.chaineToNomFichier( nomFichierSortie )
self.urlImage = urlImage
self.descriptif = lib.html.supprimeBalisesHTML( descriptif )
## Surcharge de la methode ==
# @param autre L'autre Fichier a comparer
# @return Si les 2 Fichiers sont egaux
def __eq__( self, autre ):
if not isinstance( autre, Fichier ):
return False
else:
return ( self.nom == autre.nom and self.date == autre.date and self.lien == autre.lien )
## Surcharge de la methode !=
# @param autre L'autre Fichier a comparer
# @return Si les 2 Fichiers sont differents
def __ne__( self, autre ):
return not self.__eq__( autre )
| 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 |
# -*- coding:Utf-8 -*-
## Interface des classes effectuant le téléchargement de fichiers distant.
#
#
class DownloaderInterface :
def __init__(self):
pass
## Démarre le téléchargement
# Ne doit être appelée qu'une seul fois avant l'utilisation des méthodes read ou stop.
# @return True en cas de réussite, False en cas d'échec
def start(self):
pass
## Arrête le téléchargement
def stop(self):
pass
## Lit et renvoie des octets du flux téléchargé.
#
# La méthode start doit avoir été appelé avant pour que le téléchargement soit lancé.
# @param n le nombre d'octet à lire
# @return une chaîne de charactère de taille maximale n ou de taille 0 en cas d'échec ou de fin du flux
def read (self, n) :
# returns byte[]
pass
## Renvoie la taille du fichier en cours de téléchargement.
# La valeur renvoyer peut changer en fonction de l'état du téléchargement. Il est préférable de ne l'appeler après start() ou pendant le téléchargement.
# @return la taille du téléchargement en cour en octets, None si inconnue
def getSize(self):
pass
| Python |
# -*- coding:Utf-8 -*-
class PluginStatus :
ENABLED = 0
DISABLED = 1
REFRESHING = 2
REFRESHED = 3
def __init__(self, status):
self.status = status
def getStatus(self):
return self.status
| 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 core import *
##########
# 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):
NAVIGATEUR = None
## @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" )
self.logo = os.path.join( "plugins", "img", 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:
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))
## 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 Plugin.NAVIGATEUR.getPage( 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):
#FIXME Navigateur (téléchargement full threadé) vraiment efficace ?
reponses = Plugin.NAVIGATEUR.getPages( urls )
return reponses
Plugin.NAVIGATEUR = Navigateur()
#class Plugin :
#
# def __init__( self, nom, nomComplet, nomImage ) :
# self.nom = nom # Nom du plugin (sans accents, espaces, caracteres speciaux, ...)
# self.nomComplet = nomComplet # Nom complet du plugin
# self.image = chargerImage( nomImage ) # Image representant le plugin
#
# # Cache
# #self.cache = PluginCache()
# # S'ajoute soit meme au cache
# self.cache.ajouterPlugin( self.nom )
#
# ## Methode qui charge l'image du plugin
# # @param nomImage Nom de l'image a charger
# # @return Image
# def chargerImage( self, nomImage ):
# pass
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import cPickle as pickle
import sqlite3 as sqlite
import Constantes
import logging
logger = logging.getLogger( __name__ )
##########
# Classe #
##########
class PluginCache( 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( PluginCache, self ).__new__( self )
return self.instance
def __init__( self ):
self.connexion = sqlite.connect( Constantes.FICHIER_CACHE )
self.connexion.text_factory = str
self.curseur = self.connexion.cursor()
# Nettoyage
self.clear()
def __del__( self ):
self.curseur.close()
self.connexion.close()
def creerTables( self ):
self.curseur.execute( "CREATE TABLE IF NOT EXISTS plugins ( id INTEGER PRIMARY KEY, nom TEXT );" )
self.curseur.execute( "CREATE TABLE IF NOT EXISTS chaines ( id INTEGER PRIMARY KEY, nom TEXT, idPlugin INTEGER, FOREIGN KEY( idPlugin ) REFERENCES plugins( id ) );" )
self.curseur.execute( "CREATE TABLE IF NOT EXISTS emissions ( id INTEGER PRIMARY KEY, nom TEXT, idChaine INTEGER, FOREIGN KEY( idChaine ) REFERENCES chaines( id ) );" )
self.curseur.execute( "CREATE TABLE IF NOT EXISTS fichiers ( id INTEGER PRIMARY KEY, donnees BLOB, idEmission INTEGER, FOREIGN KEY( idEmission ) REFERENCES emissions( id ) );" )
self.connexion.commit()
def clear( self ):
self.curseur.execute( "DROP TABLE IF EXISTS fichiers;" )
self.curseur.execute( "DROP TABLE IF EXISTS emissions;" )
self.curseur.execute( "DROP TABLE IF EXISTS chaines;" )
self.curseur.execute( "DROP TABLE IF EXISTS plugins;" )
self.creerTables()
self.connexion.commit()
# Met en forme dans une liste les retours de requete SQL
# d'ou il n'est extrait qu'un element
def miseEnFormeUnElement( self ):
ret = []
for res in self.curseur.fetchall():
ret.append( res[ 0 ] )
return ret
def listerPlugins( self ):
self.curseur.execute( "SELECT nom FROM plugins;" )
return self.miseEnFormeUnElement()
def listerChaines( self, nomPlugin ):
self.curseur.execute( "SELECT chaines.nom FROM chaines, plugins WHERE chaines.idPlugin = plugins.id AND plugins.nom = ?;", ( nomPlugin, ) )
return self.miseEnFormeUnElement()
def listerEmissions( self, nomChaine, nomPlugin ):
self.curseur.execute( "SELECT emissions.nom FROM emissions, chaines, plugins WHERE emissions.idChaine = chaines.id AND chaines.nom = ? AND chaines.idPlugin = plugins.id AND plugins.nom = ?;", ( nomChaine, nomPlugin ) )
return self.miseEnFormeUnElement()
def listerFichiers( self, nomEmission, nomChaine, nomPlugin ):
self.curseur.execute( "SELECT fichiers.donnees FROM fichiers, emissions, chaines, plugins WHERE fichiers.idEmission = emissions.id AND emissions.nom = ? AND emissions.idChaine = chaines.id AND chaines.nom = ? AND chaines.idPlugin = plugins.id AND plugins.nom = ?;", ( nomEmission, nomChaine, nomPlugin ) )
return map( pickle.loads, self.miseEnFormeUnElement() )
def ajouterPlugin( self, nom ):
self.curseur.execute( "INSERT INTO plugins ( nom ) VALUES ( ? );", ( nom, ) )
self.connexion.commit()
def ajouterChaine( self, nom, nomPlugin ):
self.curseur.execute( "INSERT INTO chaines ( nom, idPlugin ) VALUES ( ?, ( SELECT id FROM plugins WHERE nom = ? ) );", ( nom, nomPlugin ) )
self.connexion.commit()
def ajouterEmission( self, nom, nomChaine, nomPlugin ):
self.curseur.execute( "INSERT INTO emissions ( nom, idChaine ) VALUES ( ?, ( SELECT chaines.id FROM chaines, plugins WHERE chaines.idPlugin = plugins.id AND chaines.nom = ? AND plugins.nom = ? ) );", ( nom, nomChaine, nomPlugin ) )
self.connexion.commit()
def ajouterFichier( self, donnees, nomEmission, nomChaine, nomPlugin ):
self.curseur.execute( "INSERT INTO fichiers ( donnees, idEmission ) VALUES ( ?, ( SELECT emissions.id FROM emissions, chaines, plugins WHERE emissions.idChaine = chaines.id AND emissions.nom = ? AND chaines.idPlugin = plugins.id AND chaines.nom = ? AND plugins.nom = ? ) );", ( pickle.dumps( donnees ), nomEmission, nomChaine, nomPlugin ) )
self.connexion.commit()
| Python |
# -*- coding:Utf-8 -*-
from AbstractDownloaderFactory import *
from HttpDownloader import *
from FtpDownloader import *
from MsdlDownloader import *
from DownloaderInterface import *
## Fabrique concrète des DownloaderInterface
class DownloaderFactory (AbstractDownloaderFactory) :
def __init__(self) :
pass
## 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)
else:
return None
| Python |
#!/usr/bin/env python
import ftplib,socket,re,sys,urlparse,os
from DownloaderInterface import *
class FtpDownloader (DownloaderInterface) :
def __init__(self, url) :
DownloaderInterface.__init__(self)
self.url = url
self.ftpconn = None
self.size = None
self.stream = None
def start(self):
try:
parsed = urlparse.urlparse(self.url)
ftpconn = ftplib.FTP(parsed.netloc)
ftpconn.login()
self.stream,self.size = ftpconn.ntransfercmd("RETR "+parsed.path)
self.ftpconn = ftpconn
except BaseException as e:
import traceback
traceback.print_exc(e)
if self.stream != None:
self.stream.close()
return False
return True
def getSize(self):
return self.size
def read (self, n) :
return self.stream.recv(n)
def stop(self):
self.stream.close()
self.ftpconn.close()
@staticmethod
def canDownload (url) :
return url[:4] == "ftp:"
| Python |
# -*- coding:Utf-8 -*-
class PluginCallback :
def __init__(self) :
pass
def pluginStatus(self, pluginName, status):
pass
| Python |
# -*- coding:Utf-8 -*-
## 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 du téléchargement.
# @param downloadNum le numéro du téléchargement
# @param status le status du téléchargement (voir classe DownloadStatus)
def downloadStatus (self, downloadNum, status) :
# returns
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 os.path
import pickle
import logging
logger = logging.getLogger( __name__ )
##########
# 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
from random import choice
from traceback import print_exc
import os
import sys
from Plugin import Plugin
from PluginStatus import PluginStatus
import Constantes
import logging
logger = logging.getLogger( __name__ )
##########
# Classe #
##########
#TODO Fusion imcomplette, utiliser les setters dans le constructeur, gérer la liste
# des plugins présents, actifs et inactifs.
## 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__( self, *args, **kwargs ):
if( self.instance is None ):
self.instance = super( PluginManager, self ).__new__( self )
return self.instance
## Constructeur
def __init__( self ):
#Code venant de APIPrive
self.listePluginActif = {}
self.listePlugin = {}
# Import de tous les plugins
for rep in Constantes.REPERTOIRES_PLUGINS:
# 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 ) )
# Ajout du repertoire au path si necessaire
if not( rep in sys.path ):
sys.path.insert( 0, rep )
# 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
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 ] ) ) ):
# 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 :
logger.error( "impossible d'importer le fichier %s" %( fichier ) )
continue
## Methode qui instancie les plugins
# N.B. : doit etre lancee apres importerPlugins
def instancierPlugins( self ):
for plugin in Plugin.__subclasses__(): # Pour tous les plugins
try:
# Instance du plugin
inst = plugin()
except:
logger.error( "impossible d'instancier le plugin %s" %( plugin ) )
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
def getInstance( self, nom ):
return self.listePlugin.get( nom, None )
def addCallback( self, callback ):
self.callbacks.append(callback)
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
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
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
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
## 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.listePlugin.keys()
## Renvoie la liste des plugins (leur instance)
# @return Liste des instances des plugins
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
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
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
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
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
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
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):
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()
## 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)
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import time
import Constantes
import logging
logger = logging.getLogger( __name__ )
###########
# Classes #
###########
## Classe image
class Image( object ):
## Constructeur
# @param nom Nom de l'image
# @param donnees Donnees de l'image
# @param date Date de derniere utilisation de l'image
def __init__( self, nom, donnees = "", date = int( time.time() ) ):
self.nom = nom
self.donnees = donnees
self.date = date # timestamp
## Surcharge de la methode ==
# @param autre L'autre image a comparer
# @return Si les 2 images sont egales
def __eq__( self, autre ):
if( not isinstance( autre, Image ) ):
return False
else:
return( self.nom == autre.nom )
## Surcharge de la methode !=
# @param autre L'autre image a comparer
# @return Si les 2 images sont differentes
def __ne__( self, autre ):
return not self.__eq__( autre )
## Classe permettant de gerer les images
class Gestionnaire( 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( Gestionnaire, self ).__new__( self )
return self.instance
## Constructeur
def __init__( self ):
self.cache = {}
self.nombreAcces = 0
## Vide le cache
def viderCache( self ):
self.cache.clear()
## Nettoie le cache
# Supprime les entrees les plus vieilles du cache
def nettoieCache( self ):
if( len( self.cache ) > Constantes.TAILLE_CACHE_IMAGE ):
logger.info( "netttoieCache : le cache des images est trop important ; nettoyage" )
lienDate = []
for( lien, image ) in self.cache.items():
lienDate.append( ( image.date, lien ) )
lienDate.sort()
for i in range( len( self.cache ) - Constantes.TAILLE_CACHE_IMAGE ):
del self.cache[ lienDate[ i ][ 1 ] ]
## Recupere une image
# @param url URL de l'image
# @return L'image demandee
def getImage( self, url ):
if( self.cache.has_key( url ) ):
image = self.cache[ url ]
image.date = int( time.time() )
else:
# Telecharge l'image puis la met en cache
pass
# Nettoie le cache apres un nombre d'acces important au cache
self.nombreAcces += 1
if( self.nombreAcces > Constantes.TAILLE_CACHE_IMAGE ):
self.nettoieCache()
self.nombreAcces = 0
return image
| Python |
# -*- coding:Utf-8 -*-
class AbstractDownloaderFactory :
def __init__(self) :
pass
def create (self, url) :
# returns DownloaderInterface
pass
| Python |
# -*- coding:Utf-8 -*-
import urllib,urlparse,httplib
from DownloaderInterface import *
class HttpDownloader (DownloaderInterface) :
def __init__(self, url) :
DownloaderInterface.__init__(self)
self.url = url
self.size = None
def start(self):
parsed = urlparse.urlparse(self.url)
httpcon = httplib.HTTPConnection(parsed.netloc)
print parsed.netloc
print parsed.path+"?"+parsed.query
try:
if parsed.query != "":
httpcon.request("GET", parsed.path+"?"+parsed.query)
else:
httpcon.request("GET", parsed.path)
except:
return false
resp = httpcon.getresponse()
self.stream = resp
self.size = int(resp.getheader("Content-Length"))
print resp.getheader("Content-Length")
return True
def getSize(self):
return self.size
def read (self, n) :
return self.stream.read(n)
def stop(self):
self.stream.close()
@staticmethod
def canDownload (url) :
return url[:5] == "http:"
| Python |
# -*- coding:Utf-8 -*-
import thread,threading,traceback
from DownloaderFactory import *
from HttpDownloader import *
from FtpDownloader import *
from MsdlDownloader import *
from DownloadStatus import *
class DownloadManager(threading.Thread):
BUFFER_SIZE = 8000
def __init__(self, start=True) :
threading.Thread.__init__(self)
self.nextNumDownload = 0 # int
self.dlFactory = DownloaderFactory();
self.toDl = []
self.stpDl = []
self.mutex_toDl = thread.allocate_lock()
self.cond_toDl = threading.Condition(self.mutex_toDl)
self.stopped = True
if start:
self.start()
def start(self):
self.stopped = False
threading.Thread.start(self)
def stop(self):
self.mutex_toDl.acquire()
self.stopped = True
for dlParam in self.toDl:
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(0, DownloadStatus.STOPPED))
self.toDl = []
self.cond_toDl.notifyAll()
self.mutex_toDl.release()
def stopDownload(self, num):
self.mutex_toDl.acquire()
found = False
for dlParam in self.toDl:
if dlParam[3] == num:
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(0, DownloadStatus.STOPPED))
found = True
break
if not(found):
self.stpDl.append(num)
self.mutex_toDl.release()
def run(self):
while True:
if self.mutex_toDl.locked():
print "run: Mutex verrouillé, attention au dead lock !"
self.mutex_toDl.acquire()
while len(self.toDl) <= 0:
if len(self.stpDl) > 0:
for dlParam in self.toDl:
if dlParam[3] in self.stpDl:
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(0, DownloadStatus.STOPPED))
self.stpDl = []
if self.stopped:
print "Arrêt!"
self.mutex_toDl.release()
return
print "En attente..."
self.cond_toDl.wait();
dlParam = self.toDl.pop(0)
self.mutex_toDl.release()
print "Téléchargement de "+dlParam[0]+"..."
dler = self.getDownloader(dlParam[0])
if dler == None:
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(0, DownloadStatus.FAILED))
continue
try:
outfile = open(dlParam[1], "w")
if dler.start():
carac = dler.read(DownloadManager.BUFFER_SIZE)
dled = len(carac)
last_perc = 0
while len(carac) > 0:
if dlParam[3] in self.stpDl:
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(last_perc, DownloadStatus.STOPPED))
break
if self.stopped:
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(last_perc, DownloadStatus.STOPPED))
print "Arrêt!"
return
outfile.write(carac)
carac = dler.read(DownloadManager.BUFFER_SIZE)
dled = dled+len(carac)
size = dler.getSize()
new_perc = (100.0*dled)/size
if size == None:
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(None, DownloadStatus.DOWN))
elif new_perc > last_perc:
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(new_perc, DownloadStatus.DOWN))
last_perc = new_perc
outfile.close()
dler.stop()
if not(self.stopped) and not(dlParam[3] in self.stpDl):
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(last_perc, DownloadStatus.COMPLETED))
else:
print "Echec de téléchargement !"
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(0, DownloadStatus.FAILED))
except BaseException as e:
print "Erreur de téléchargement !"
dlParam[2].downloadStatus(dlParam[3], DownloadStatus(0, DownloadStatus.FAILED))
traceback.print_exc(e)
print "Arrêt anormal!"
# Renvoie None si aucun downloader trouvé
def getDownloader(self, url):
return self.dlFactory.create(url)
## Lance ou met en attente un téléchargement.
# @param url l'url du fichier distant
# @param outfile le chemin du fichier de sauvegarde
# @param callback le DownloadCallback à tenir informé de l'état du téléchargement
# @return le numéro du téléchargement
def download (self, url, outFile, callback) :
if self.mutex_toDl.locked():
print "down: Mutex verrouillé, attention au dead lock !"
self.mutex_toDl.acquire()
self.toDl.append([url, outFile, callback, self.nextNumDownload])
callback.downloadStatus(self.nextNumDownload, DownloadStatus(0, DownloadStatus.QUEUED))
self.cond_toDl.notifyAll()
self.mutex_toDl.release()
self.nextNumDownload = self.nextNumDownload+1
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
from AbstractDownloaderFactory import *
from Constantes import *
from DownloadCallback import *
from DownloaderFactory import *
from DownloaderInterface import *
from DownloadManager import *
from DownloadStatus import *
from HttpDownloader import *
from Fichier import *
from FtpDownloader import *
from MsdlDownloader import *
from Navigateur import *
from Option import *
from PluginCache import *
from PluginCallback import *
from Plugin import *
from PluginManager import *
from PluginStatus import *
| Python |
# -*- coding:Utf-8 -*-
import subprocess,shlex,re,ctypes
libmms = ctypes.cdll.LoadLibrary("libmms.so.0")
from DownloaderInterface import *
class MsdlDownloader (DownloaderInterface) :
def __init__(self, url) :
DownloaderInterface.__init__(self)
self.url = url
self.size = None
def start(self):
try:
self.mmscon = libmms.mmsx_connect(None, None, self.url, int(5000))
if self.mmscon == 0:
return False
self.size = libmms.mmsx_get_length(self.mmscon)
except Exception as e:
import traceback
traceback.print_exc(e)
return False
return True
def read (self, n):
buffer = ctypes.create_string_buffer(n)
libmms.mmsx_read(0, self.mmscon, buffer, n)
return buffer.value
def stop(self):
libmms.mmsx_close(self.mmscon)
def getSize(self):
return self.size
@staticmethod
def canDownload (url) :
return url[:4] == "mms:"
| Python |
# -*- coding:Utf-8 -*-
## 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 p la progession du téléchargement en %
# @param s l'état dans lequel se trouve le téléchargement (QUEUED,PAUSED,DOWN,STOPPED,FAILED,COMPLETED)
# @param sz la taille en octet du fichier téléchargé
def __init__(self, p, s, sz=0):
self.progress = p
self.status = s
self.size = sz
## Renvoie la progression du téléchargement en %
# @return un nombre entre 0 et 100 ou None si inconnue
def getProgression(self):
return self.progress
## Renvoie la taille du fichier en cour de téléchargement.
# @return la taille en octet ou 0 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
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# 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" ] )
FICHIER_CACHE = os.path.join( REPERTOIRE_HOME, "cache.db" )
REPERTOIRE_CONFIGURATION = os.path.join( REPERTOIRE_HOME, "config" )
elif( "APPDATA" in os.environ ):
REPERTOIRE_HOME = os.path.join( os.environ[ "APPDATA" ], "tvdownloader" )
FICHIER_CACHE = os.path.join( REPERTOIRE_HOME, "cache.db" )
REPERTOIRE_CONFIGURATION = os.path.join( REPERTOIRE_HOME, "config" )
else:
REPERTOIRE_HOME = os.path.expanduser( "~" )
FICHIER_CACHE = os.path.join( REPERTOIRE_HOME, ".cache", "tvdownloader.db" )
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" )
FICHIER_HISTORIQUE_TVD = os.path.join( REPERTOIRE_CONFIGURATION, "historique" )
# des caches
TAILLE_CACHE_IMAGE = 25
| 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 *
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 |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import threading
import Constantes
# import lib
from PyQt4 import QtGui, QtCore
from gui.Qt.MyQPushButton import MyQPushButton
from gui.Qt.MyQTableWidget import MyQTableWidget
import logging
logger = logging.getLogger( __name__ )
# import threading
#
# import Constantes
#
# from PyQt4 import QtGui, QtCore
from core.PluginManager import PluginManager
#
# from API import API
# from Fichier import Fichier
# from GUI.AProposDialog import AProposDialog
# from GUI.ConvertQString import *
# from GUI.Downloader import Downloader
# from GUI.FenetreAttenteProgressDialog import FenetreAttenteProgressDialog
# from GUI.PreferencePluginDialog import PreferencePluginDialog
# from GUI.PreferencesDialog import PreferencesDialog
# from GUI.UpdateManagerDialog import UpdateManagerDialog
# from Historique import Historique
# from PluginManager import PluginManager
# from Preferences import Preferences
#
# import logging
# logger = logging.getLogger( __name__ )
##########
# Classe #
##########
## Fenetre principale de l'application
class MainWindow( QtGui.QMainWindow ):
## Constructeur
# Cree la fenetre principale en y ajoutant tous les widgets necessaires au programme
def __init__( self ):
# Appel au constructeur de la classe mere
QtGui.QMainWindow.__init__( self )
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle( "%s %s" %( Constantes.TVD_NOM, Constantes.TVD_VERSION ) )
# Mise en place de son icone
self.setWindowIcon( QtGui.QIcon( "ico/TVDownloader.png" ) )
###
# Mise en place des widgets dans la fenetre
###
# Widget central qui contiendra tout
self.centralWidget = QtGui.QWidget( self )
#
# Onglets
#
# Gestionnaire onglets
self.tabWidget = QtGui.QTabWidget( self.centralWidget )
# Onglet Fichiers
self.tabFichiers = QtGui.QWidget( self.centralWidget )
self.tabWidget.addTab( self.tabFichiers, u"Fichiers" )
# Onglet Telechargements
self.tabTelechargements = QtGui.QWidget( self.centralWidget )
self.tabWidget.addTab( self.tabTelechargements, u"Téléchargements" )
#
# Onglet Fichiers
#
# Layout de grille qui contient les elements de l'onglet Fichier
self.gridLayoutFichiers = QtGui.QGridLayout( self.tabFichiers )
# Liste des plugins
self.listWidgetPlugins = QtGui.QListWidget( self.tabFichiers )
self.listWidgetPlugins.setIconSize( QtCore.QSize( 75, 75 ) )
self.gridLayoutFichiers.addWidget( self.listWidgetPlugins, 0, 0, 4, 1 )
# Liste des chaines
self.listWidgetChaines = QtGui.QListWidget( self.tabFichiers )
self.gridLayoutFichiers.addWidget( self.listWidgetChaines, 0, 1, 1, 1 )
# Liste des emissions
self.listWidgetEmissions = QtGui.QListWidget( self.tabFichiers )
self.gridLayoutFichiers.addWidget( self.listWidgetEmissions, 0, 2, 1, 1 )
# Logo de l'emission
self.logoFichierDefaut = QtGui.QPixmap()
self.logoFichierDefaut.load( "img/logoVide.svg" )
self.labelLogo = QtGui.QLabel( self.tabFichiers )
self.labelLogo.setScaledContents( True )
self.labelLogo.setPixmap( self.logoFichierDefaut.scaled( QtCore.QSize( 150, 150 ), QtCore.Qt.KeepAspectRatio ) )
self.gridLayoutFichiers.addWidget( self.labelLogo, 0, 3, 1, 1 )
# Descriptif du fichier
# self.plainTextEditDescriptif = QtGui.QPlainTextEdit( self.tabFichiers )
# self.gridLayoutFichiers.addWidget( self.plainTextEditDescriptif, 3, 1, 1, 3 )
#
# Onglet Fichiers - Liste des fichiers
#
# Layout de grille qui contient le tableau qui liste les fichiers et ses boutons
self.gridLayoutListeFichiers = QtGui.QGridLayout( self.tabFichiers )
# Tableau qui contient la liste des fichiers disponibles pour l'emission courante
self.tableWidgetFichier = MyQTableWidget( self.tabFichiers )
# Il a 4 colonnes et 0 ligne (pour l'instant)
self.tableWidgetFichier.setColumnCount( 3 )
self.tableWidgetFichier.setRowCount( 0 )
# On ajoute les titres
self.tableWidgetFichier.setHorizontalHeaderItem( 0,
self.tableWidgetFichier.creerItem( "" ) )
self.tableWidgetFichier.setHorizontalHeaderItem( 1,
self.tableWidgetFichier.creerItem( "Date" ) )
self.tableWidgetFichier.setHorizontalHeaderItem( 2,
self.tableWidgetFichier.creerItem( "Emission" ) )
# Ajout au layout
self.gridLayoutListeFichiers.addWidget( self.tableWidgetFichier, 0, 1, 4, 3 )
# Icones du tableWidget
self.iconeFichier = QtGui.QIcon( "ico/gtk-file.svg" )
self.iconeAjoute = QtGui.QIcon( "ico/gtk-add.svg" )
self.iconeTelecharge = QtGui.QIcon( "ico/gtk-apply.svg" )
# Bouton pour lire le fichier selectionnne
self.pushButtonLire = MyQPushButton( self.tabFichiers )
self.pushButtonLire.setIcon( QtGui.QIcon( "ico/gtk-media-play-ltr.svg" ) )
self.pushButtonLire.setToolTip( u"Lire la vidéo selectionnée" )
self.gridLayoutListeFichiers.addWidget( self.pushButtonLire, 0, 0, 1, 1 )
# Bouton pour ajouter tous les fichiers a la liste des telechargements
self.pushButtonToutAjouter = MyQPushButton( self.tabFichiers )
self.pushButtonToutAjouter.setIcon( QtGui.QIcon( "ico/gtk-add.svg" ) )
self.pushButtonToutAjouter.setToolTip( u"Ajouter tous les fichiers à la liste des téléchargements" )
self.gridLayoutListeFichiers.addWidget( self.pushButtonToutAjouter, 1, 0, 1, 1 )
# Bouton pour rafraichir le plugin courant
self.pushButtonRafraichirPlugin = MyQPushButton( self.tabFichiers )
self.pushButtonRafraichirPlugin.setIcon( QtGui.QIcon( "ico/gtk-refresh.svg" ) )
self.pushButtonRafraichirPlugin.setToolTip( "Rafraichir le plugin" )
self.gridLayoutListeFichiers.addWidget( self.pushButtonRafraichirPlugin, 2, 0, 1, 1 )
# Bouton pour ouvrir la fenetre des preferences du plugin courant
self.pushButtonPreferencesPlugin = MyQPushButton( self.tabFichiers )
self.pushButtonPreferencesPlugin.setIcon( QtGui.QIcon( "ico/gtk-preferences.svg" ) )
self.pushButtonPreferencesPlugin.setToolTip( u"Ouvrir les préférences du plugin" )
self.gridLayoutListeFichiers.addWidget( self.pushButtonPreferencesPlugin, 3, 0, 1, 1 )
# Mise en place du layout sur un widget
self.widgetFichiers = QtGui.QWidget( self.tabFichiers )
self.widgetFichiers.setLayout( self.gridLayoutListeFichiers )
self.gridLayoutFichiers.addWidget( self.widgetFichiers, 1, 1, 2, 3 )
#
# Barre progression de telechargement d'un fichier
#
self.progressBarTelechargementFichier = QtGui.QProgressBar( self.centralWidget )
self.progressBarTelechargementFichier.setProperty( "value", 0 )
#
# Barre de progression de telechargement des fichiers
#
self.progressBarTelechargement = QtGui.QProgressBar( self.centralWidget )
self.progressBarTelechargement.setProperty( "value", 0 )
#
# Boutons du bas pour gerer ajouter/supprimer/lancer telechargements
#
# Layout horizontal qui contiendra les boutons
self.horizontalLayoutBarreBas = QtGui.QHBoxLayout()
# Bouton pour lancer les telechargements
self.pushButtonLancer = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-play-ltr.svg" ), u"Lancer téléchargement", self.centralWidget )
self.horizontalLayoutBarreBas.addWidget( self.pushButtonLancer )
# Bouton pour stopper les telechargements
self.pushButtonStop = QtGui.QPushButton( QtGui.QIcon( "ico/gtk-media-stop.svg" ), u"Stopper le téléchargement", self.centralWidget )
self.pushButtonStop.setEnabled( False )
self.horizontalLayoutBarreBas.addWidget( self.pushButtonStop )
###
# Positionnement des differents widgets/layouts sur le layout de grille
###
# Layout de grille dans lequel on va placer nos widgets/layouts
self.gridLayout = QtGui.QGridLayout( self.centralWidget )
self.gridLayout.addWidget( self.tabWidget, 0, 0, 1, 2 )
self.gridLayout.addWidget( self.progressBarTelechargementFichier, 2, 0, 1, 3 )
self.gridLayout.addWidget( self.progressBarTelechargement, 3, 0, 1, 3 )
self.gridLayout.addLayout( self.horizontalLayoutBarreBas, 4, 0, 1, 3 )
###
# Mise en place du central widget dans la fenetre
###
self.setCentralWidget( self.centralWidget )
###
# Mise en place du menu
###
# Menu barre
self.menubar = QtGui.QMenuBar( self )
self.menubar.setGeometry( QtCore.QRect( 0, 0, 480, 25 ) )
# Menu Fichier
self.menuFichier = QtGui.QMenu( "&Fichier", self.menubar )
self.menubar.addAction( self.menuFichier.menuAction() )
# Action Fichier -> Quitter
self.actionQuitter = QtGui.QAction( QtGui.QIcon( "ico/gtk-quit.svg" ), "&Quitter", self.menuFichier )
self.actionQuitter.setIconVisibleInMenu( True )
self.menuFichier.addAction( self.actionQuitter )
# Menu Edition
self.menuEdition = QtGui.QMenu( "&Edition", self.menubar )
self.menubar.addAction( self.menuEdition.menuAction() )
# Action Edition -> Mise a jour
self.actionMAJ = QtGui.QAction( QtGui.QIcon( "ico/gtk-refresh.svg" ), u"&Mise à jour des plugins", self.menuEdition )
self.actionMAJ.setIconVisibleInMenu( True )
self.menuEdition.addAction( self.actionMAJ )
# Action Edition -> Preferences
self.actionPreferences = QtGui.QAction( QtGui.QIcon( "ico/gtk-preferences.svg" ), u"&Préférences", self.menuEdition )
self.actionPreferences.setIconVisibleInMenu( True )
self.menuEdition.addAction( self.actionPreferences )
# Menu Aide
self.menuAide = QtGui.QMenu( "&Aide", self.menubar )
self.menubar.addAction( self.menuAide.menuAction() )
# Action Aide -> A propos
self.actionAPropos = QtGui.QAction( QtGui.QIcon( "ico/gtk-about.svg" ), u"À p&ropos", self.menuAide )
self.actionAPropos.setIconVisibleInMenu( True )
self.menuAide.addAction( self.actionAPropos )
# Ajout du menu a l'interface
self.setMenuBar( self.menubar )
self.resize( 500, 500 )
################################################
# Instanciations + initialisation de variables #
################################################
# Plugin Manager
self.pluginManager = PluginManager()
# Mise en place des plugins
self.ajouterPlugins( [ ( inst.nom, inst.logo ) for inst in self.pluginManager.getPluginListeInstances() ] )
## Execute les actions necessaires avant de quitter le programme
def actionsAvantQuitter( self ):
pass
#########################################
# Surcharge des methodes de QMainWindow #
#########################################
## Surcharge de la methode appelee lors de la fermeture de la fenetre
# Ne doit pas etre appele explicitement
# @param evenement Evenement qui a provoque la fermeture
def closeEvent( self, evenement ):
pass
##################################################################
# Methodes qui remplissent les elements de l'onglet de recherche #
##################################################################
## Ajoute les plugins
# @param listePlugins Liste des plugins sous la forme [ ( nom, image ) ]
def ajouterPlugins( self, listePlugins ):
for ( nom, logo ) in listePlugins:
item = QtGui.QListWidgetItem( QtGui.QIcon( logo ), "" )
item.setToolTip( nom )
self.listWidgetPlugins.addItem( item )
## Ajoutes les chaines
# @param listeChaines Liste des chaines
def ajouterChaines( self, listeChaines ):
pass
## Ajoute les emissions
# @param listeEmissions Liste des emissions
def ajouterEmissions( self, listeEmissions ):
pass
## Ajoute le logo de l'emission selectionnee
# @param cheminLogo Chemin du logo
def ajouterLogoEmission( self, cheminLogo ):
pass
## Ajoute les fichiers
# @param listeFichiers Liste des fichiers
def ajouterFichiers( self, listeFichiers ):
pass
## Ajoute le descriptif du fichier selectionne
# @param descriptif Descriptif du fichier
def ajouterDescriptif( self, descriptif ):
pass
##################################
# Slots de l'onglet de recherche #
##################################
## Liste les chaines d'un plugin
# @param nomPlugin Nom du plugin
def listerChaines( self, nomPlugin ):
pass
## Liste les emissions d'une chaine
# @param nomChaine Nom de la chaine
# @param nomPlugin Nom du plugin
def listerEmissions( self, nomChaine, nomPlugin ):
pass
## Liste les fichiers d'une emissions
# @param nomEmission Nom d'une emission
# @param nomChaine Nom de la chaine
# @param nomPlugin Nom du plugin
def listerFichiers( self, nomEmission, nomChaine, nomPlugin ):
pass
## Rafraichit un plugin
# @param nomPlugin Nom du plugin a rafraichir
def rafraichirPlugin( self, nomPlugin ):
pass
#######################################################################
# Methodes qui remplissent les elements de l'onglet de telechargement #
#######################################################################
#######################################
# Slots de l'onglet de telechargement #
#######################################
##############################################
# Slots pour l'ouverture des autres fenetres #
##############################################
## Ouvre la fenetre About
def ouvrirFenetreAPropos( self ):
pass
## Ouvre les preferences du logiciel
def ouvrirPreferencesLogiciel( self ):
pass
## Ouvre la fenetre de mise a jour des plugins
def ouvrirFenetreMiseAJour( self ):
pass
## Ouvre les preferences du plugin courant
# @param nomPlugin Nom du plugin
def ouvrirPreferencesPlugin( self, nomPlugin ):
pass
## Ouvre le repertoire de telechargement
def ouvrirRepertoireTelechargement( self ):
pass
| 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_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 |
#!/bin/python
from cmd import Cmd
import sys
from core import *
class Cli(Cmd):
EXEC_MAP = {"quit": [sys.exit, (0,)],
"help": [sys.stdout.write, (help,)]}
def __init__(self):
Cmd.__init__(self)
self.execs = [MainExec()]
def onecmd(self, cmdText):
if len(self.execs) == 0:
sys.exit(0)
else:
args = cmdText.split(" ")
res = self.execs[len(self.execs)-1].execCmd(args[0], args[1:])
if isinstance(res, CmdExec):
self.execs.append(res)
elif not(res):
self.execs.pop()
# cmdKey = cmdText
# res = Cli.EXEC_MAP[cmdText][0](*Cli.EXEC_MAP[cmdText][1])
# if res:
# if type(res) == list:
# for e in res:
# print " ",e
# else:
# print res
class CmdExec(object):
def __init__(self):
object.__init__(self)
def execCmd(self, cmd, args):
if cmd == "retour":
return False;
if not(self.EXEC_MAP.has_key(cmd)):
print "Commande inconnue"
return True
res = self.EXEC_MAP[cmd][0](*self.EXEC_MAP[cmd][1])
if res:
if type(res) == list:
for e in res:
print " ",e
else:
print res
return True
MAIN_HELP = """Liste des commandes:
plugin (list|activer|desactiver)
chaine (nomPlugin)
emission (nomPlugin) (chaine)
fichier (nomPlugin) (emission)
downloads
retour
"""
PLUGIN_MANAGER = PluginManager()
class MainExec(CmdExec):
def __init__(self):
CmdExec.__init__(self)
self.EXEC_MAP = MainExec.EXEC_MAP;
EXEC_MAP = {"quit": [sys.exit, (0,)],
"help": [sys.stdout.write, (MAIN_HELP,)],
"plugin": [PLUGIN_MANAGER.getPluginListe, ()]}
def execCmd(self, cmd, args):
if cmd == "downloads":
return DownloadExec()
else:
return CmdExec.execCmd(self, cmd, args)
# if cmd == "retour":
# return False;
# if not(MainExec.EXEC_MAP.has_key(cmd)):
# print "Commande inconnue"
# return True
# res = MainExec.EXEC_MAP[cmd][0](*MainExec.EXEC_MAP[cmd][1])
# if res:
# if type(res) == list:
# for e in res:
# print " ",e
# else:
# print res
# return True
class DownloadExec(CmdExec):
def __init__(self):
CmdExec.__init__(self)
cli = Cli()
cli.cmdloop()
| 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
# Modules de TVD
from core import Fichier, 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.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.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
# Modules de TVD
from core import Fichier, 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.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 urllib import quote
import re,unicodedata,datetime
# Modules de TVD
from core import *
##########
# 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.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.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.getPage(fichier))
if fichierInfosUrl_match == None:
continue
fichierInfos = self.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
# Modules de TVD
from core import Fichier, 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.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 urllib import quote,unquote
import re,unicodedata
import time,rfc822 # for RFC822 datetime format (rss feed)
from datetime import datetime
from htmlentitydefs import name2codepoint
from core import Plugin
from core import Fichier
##########
# 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.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.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.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
# Modules de TVD
from core import Fichier, 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.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
# Modules de TVD
from core import Fichier, 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.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
import os.path
#~ import pickle
import xml.sax
from Podcasts import PodcastsHandler
# Modules de TVD
from core import Fichier, 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.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.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.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 #
###########
# Modules Python
import datetime
import os.path
import re
import xml.sax
from xml.sax.handler import ContentHandler
# Modules de TVD
from core import Fichier, 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, "CanalPlus.jpg" )
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.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.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.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 -*-
###########
# 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 -*-
###########
# Modules #
###########
import unittest
from core import PluginCache
###########
# Classes #
###########
class FichierTest:
def __init__( self, a, b ):
self.a = a
self.b = b
class PluginCacheTest( unittest.TestCase ):
def setUp( self ):
self.pc = PluginCache()
self.pc.clear()
def testListesVideos( self ):
"""
Les methodes de listage doivent retourner des listes vides si la BDD est vide
"""
self.assertEqual( self.pc.listerPlugins(), [] )
self.assertEqual( self.pc.listerChaines( "test" ), [] )
self.assertEqual( self.pc.listerEmissions( "test", "test" ), [] )
self.assertEqual( self.pc.listerFichiers( "test", "test", "test" ), [] )
def testListePlugins( self ):
"""
La liste des plugins doit etre correcte
"""
listePlugins = [ "France Tele", "Arte", "Radio France" ]
for plugin in listePlugins:
self.pc.ajouterPlugin( plugin )
self.assertEqual( self.pc.listerPlugins(), listePlugins )
def testListeChaines( self ):
"""
La liste des chaines doit etre correcte
"""
listePlugins = [ "France Tele", "Arte", "Radio France" ]
for plugin in listePlugins:
self.pc.ajouterPlugin( plugin )
listeChainesFranceTele = [ "France 2", "France 3", "France 5" ]
for chaine in listeChainesFranceTele:
self.pc.ajouterChaine( chaine, "France Tele" )
listeChainesRadioFrance = [ "France Inter", "France Bleu" ]
for chaine in listeChainesRadioFrance:
self.pc.ajouterChaine( chaine, "Radio France" )
self.assertEqual( self.pc.listerChaines( "France Tele" ), listeChainesFranceTele )
self.assertEqual( self.pc.listerChaines( "Arte" ), [] )
self.assertEqual( self.pc.listerChaines( "Radio France" ), listeChainesRadioFrance )
def testListeEmissions( self ):
"""
La liste des emissions doit etre correcte
"""
listePlugins = [ "France Tele", "Arte", "Radio France" ]
for plugin in listePlugins:
self.pc.ajouterPlugin( plugin )
listeChainesFranceTele = [ "France 2", "France 3", "France 5" ]
for chaine in listeChainesFranceTele:
self.pc.ajouterChaine( chaine, "France Tele" )
listeChainesRadioFrance = [ "France Inter", "France Bleu" ]
for chaine in listeChainesRadioFrance:
self.pc.ajouterChaine( chaine, "Radio France" )
listeEmissionsFrance2 = [ "Motus", "Pyramide" ]
for emission in listeEmissionsFrance2:
self.pc.ajouterEmission( emission, "France 2", "France Tele" )
listeEmissionsFrance5 = [ "C dans l'air", "Les Maternelles", "Silence ça pousse" ]
for emission in listeEmissionsFrance5:
self.pc.ajouterEmission( emission, "France 5", "France Tele" )
listeEmissionsFranceInter = [ "le 6/7", "Le fou du roi", "Le jeu des mille euros" ]
for emission in listeEmissionsFranceInter:
self.pc.ajouterEmission( emission, "France Inter", "Radio France" )
self.assertEqual( self.pc.listerEmissions( "France 2", "France Tele" ), listeEmissionsFrance2 )
self.assertEqual( self.pc.listerEmissions( "France 3", "France Tele" ), [] )
self.assertEqual( self.pc.listerEmissions( "France 5", "France Tele" ), listeEmissionsFrance5 )
self.assertEqual( self.pc.listerEmissions( "France Inter", "Radio France" ), listeEmissionsFranceInter )
self.assertEqual( self.pc.listerEmissions( "France Bleu", "Radio France" ), [] )
def testSerializationFichiers( self ):
"""
Les fichiers sont bien serializes dans la BDD
"""
self.pc.ajouterPlugin( "plugin" )
self.pc.ajouterChaine( "chaine", "plugin" )
self.pc.ajouterEmission( "emission", "chaine", "plugin" )
a = [ 2, 3, 5, 7, 11, 13 ]
b = "test"
f = FichierTest( a, b )
self.pc.ajouterFichier( f, "emission", "chaine", "plugin" )
f2 = self.pc.listerFichiers( "emission", "chaine", "plugin" )[ 0 ]
self.assertEqual( f2.a, a )
self.assertEqual( f2.b, b )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import sys
sys.path.append( "../" )
import unittest
from PluginCache import PluginCacheTest
#########
# Debut #
#########
if __name__ == '__main__':
unittest.main()
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
###########
# Modules #
###########
import re
import logging
logger = logging.getLogger( __name__ )
#############
# 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( __name__ )
#############
# 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( self, 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 -*-
###########
# Modules #
###########
# import os
import logging
logger = logging.getLogger( __name__ )
#############
# Fonctions #
#############
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import ConfigParser
import os
import shutil
import sys
import logging
logger = logging.getLogger( "pluzzdl" )
#
# Fonction
#
def resourcePath( relative ):
if( getattr( sys, "frozen", None ) ):
basedir = sys._MEIPASS
else:
basedir = os.path.dirname( __file__ )
return os.path.join( basedir, relative )
#
# Classe
#
class Configuration( object ):
def __init__( self ):
# Les chemins sont differents selon l'OS utilise
if( os.name == "nt" ):
self.configDefaultFileName = resourcePath( "pluzzdl_default.cfg" )
self.configFileName = resourcePath( "pluzzdl.cfg" )
else:
self.configDefaultFileName = os.path.join( os.path.dirname( os.path.abspath( __file__ ) ), "pluzzdl_default.cfg" )
self.configFileName = os.path.join( os.path.expanduser( "~" ), ".config", "pluzzdl.cfg" )
# Si le fichier de configuration n'est pas present dans le repertoire de l'utilisateur ou si celui par defaut est plus recent
if( os.path.exists( self.configDefaultFileName ) and ( ( not os.path.exists( self.configFileName ) ) or ( os.path.getmtime( self.configDefaultFileName ) > os.path.getmtime( self.configFileName ) ) ) ):
# Copie du fichier par defaut
logger.info( "Copie du fichier de configuration par défaut" )
try:
shutil.copyfile( self.configDefaultFileName, self.configFileName )
except:
logger.error( "Impossible de copier le fichier de configuration par défaut dans le home de l'utilisateur" )
sys.exit( 1 )
# Verifie que le fichier de configuration existe
if( not os.path.exists( self.configFileName ) ):
logger.error( "Le fichier de configuration %s n'existe pas..." % ( self.configFileName ) )
sys.exit( 1 )
# Parser
self.configParser = ConfigParser.RawConfigParser()
# Options
self.optionsDict = {}
# Lecture de la configuration
self.readConfig()
def __getitem__( self, key ):
if( self.optionsDict.has_key( key ) ):
return self.optionsDict[ key ]
else:
return None
def __setitem__( self, key, value ):
self.optionsDict[ key ] = value
def readConfig( self ):
try:
self.configParser.read( self.configFileName )
for section in self.configParser.sections():
for option in self.configParser.options( section ):
self.optionsDict[ option ] = self.configParser.get( section, option )
except:
logger.error( "Impossible de lire le fichier de configuration" )
sys.exit( 1 )
def writeConfig( self ):
try:
# Seule l'option "player_hash" a ete modifiee
self.configParser.set( "Keys", "player_hash", self.optionsDict[ "player_hash" ] )
with open( self.configFileName, "wb" ) as configFile:
self.configParser.write( configFile )
except:
logger.error( "Impossible d'écrire le fichier de configuration" )
| Python |
#!/usr/bin/env python2
# -*- coding:Utf-8 -*-
#
# Modules
#
import cPickle as pickle
import datetime
import os
import logging
logger = logging.getLogger( "pluzzdl" )
#
# Classes
#
class Video( object ):
def __init__( self, lien, fragments, finie, date = datetime.datetime.now() ):
self.lien = lien
self.fragments = fragments
self.finie = finie
self.date = date
def __eq__( self, other ):
if not isinstance( other, Video ):
return False
else:
return ( self.lien == other.lien )
def __ne__( self, other ):
return not self.__eq__( other )
class Historique( object ):
def __init__( self ):
# Le chemin du fichier d'historique est different selon l'OS utilise
if( os.name == "nt" ):
self.fichierCache = "pluzzdl.cache"
else:
dossierCache = os.path.join( os.path.expanduser( "~" ), ".cache" )
if( not os.path.exists( dossierCache ) ):
logger.info( "Création du dossier %s" % ( dossierCache ) )
try:
os.makedirs( dossierCache )
except:
logger.warning( "Impossible de créer le dossier %s" % ( dossierCache ) )
self.fichierCache = os.path.join( dossierCache, "pluzzdl" )
self.charger()
def __del__( self ):
self.sauver()
def charger( self ):
if( os.path.exists( self.fichierCache ) ):
try:
with open( self.fichierCache, "r" ) as fichier:
self.historique = pickle.load( fichier )
logger.debug( "Historique chargé" )
except:
self.historique = []
logger.warning( "Impossible de lire le fichier d'historique %s, création d'un nouveau fichier" % ( self.fichierCache ) )
else:
self.historique = []
logger.info( "Fichier d'historique indisponible, création d'un nouveau fichier" )
def sauver( self ):
self.nettoyer()
try:
with open( self.fichierCache, "w" ) as fichier:
pickle.dump( self.historique, fichier )
logger.debug( "Historique sauvé" )
except:
logger.warning( "Impossible d'écrire le fichier d'historique %s" % ( self.fichierCache ) )
def nettoyer( self ):
# Supprimer les videos de plus de 10 jours de l'historique
for i in range( len( self.historique ) - 1, 0, -1 ):
if( ( datetime.datetime.now() - self.historique[ i ].date ) > datetime.timedelta( days = 10 ) ):
del self.historique[ i ]
def ajouter( self, video ):
if( isinstance( video, Video ) ):
if( video in self.historique ):
self.historique[ self.historique.index( video ) ] = video
else:
self.historique.append( video )
def getVideo( self, lienVideo ):
video = None
for v in self.historique:
if( v.lien == lienVideo ):
video = v
break
return video
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
#
# Modules
#
import cookielib
import random
import urllib2
import socks
import socket
import logging
logger = logging.getLogger( "pluzzdl" )
#
# Classe
#
class Navigateur:
timeOut = 60
listeUserAgents = [ '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, proxySock = False ):
self.proxy = proxy
# Cookiejar + urlopener
self.cookiejar = cookielib.CookieJar()
if( proxy is None ):
self.urlOpener = urllib2.build_opener( urllib2.HTTPCookieProcessor( self.cookiejar ) )
else:
if( proxySock ):
sockAddr, sockPort = self.proxy.split( ":" )
socks.setdefaultproxy( socks.PROXY_TYPE_SOCKS5, sockAddr, sockPort )
socket.socket = socks.socksocket
self.urlOpener = urllib2.build_opener( urllib2.HTTPCookieProcessor( self.cookiejar ) )
else:
self.urlOpener = urllib2.build_opener( urllib2.HTTPCookieProcessor( self.cookiejar ), urllib2.ProxyHandler( { 'http' : self.proxy } ) )
# Spoof de l'user-agent
self.urlOpener.addheaders = [ ( 'User-agent', random.choice( self.listeUserAgents ) ) ]
def getFichier( self, url, referer = None ):
try:
logger.debug( "GET %s" % ( url ) )
requete = urllib2.Request( url )
if( referer is not None ):
requete.add_header( "Referer", referer )
page = self.urlOpener.open( requete, timeout = self.timeOut )
donnees = page.read()
return donnees
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
def appendCookie( self, cookieName, cookieValue ):
for cookie in self.cookiejar:
if( cookie.name == cookieName ):
cookie.value += "; %s" % ( cookieValue )
break
| Python |
#!/usr/bin/env python2
# -*- coding:Utf-8 -*-
#
# Infos
#
__author__ = "Chaoswizard"
__license__ = "GPL 2"
__version__ = "0.9.4"
__url__ = "http://code.google.com/p/tvdownloader/"
#
# Modules
#
import argparse
import logging
import platform
import re
import sys
from ColorFormatter import ColorFormatter
from PluzzDL import PluzzDL, PluzzDLException
#
# Main
#
if( __name__ == "__main__" ) :
# Arguments de la ligne de commande
usage = "pluzzdl [options] urlEmission"
parser = argparse.ArgumentParser( usage = usage, description = "Télécharge les émissions de Pluzz" )
parser.add_argument( "-b", "--progressbar", action = "store_true", default = False, help = 'affiche la progression du téléchargement' )
parser.add_argument( "-p", "--proxy", dest = "proxy", metavar = "PROXY", help = 'utilise un proxy HTTP au format suivant http://URL:PORT' )
parser.add_argument( "-s", "--sock", action = "store_true", default = False, help = 'si un proxy est fourni avec l\'option -p, un proxy SOCKS5 est utilisé au format suivant ADRESSE:PORT' )
parser.add_argument( "-v", "--verbose", action = "store_true", default = False, help = 'affiche les informations de debugage' )
parser.add_argument( "-t", "--soustitres", action = "store_true", default = False, help = 'récupère le fichier de sous-titres de la vidéo (si disponible)' )
parser.add_argument( "--nocolor", action = 'store_true', default = False, help = 'désactive la couleur dans le terminal' )
parser.add_argument( "--version", action = 'version', version = "pluzzdl %s" % ( __version__ ) )
parser.add_argument( "urlEmission", action = "store", help = "URL de l'émission Pluzz a charger" )
args = parser.parse_args()
# Mise en place du logger
logger = logging.getLogger( "pluzzdl" )
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( ColorFormatter( not args.nocolor ) )
logger.addHandler( console )
# Affiche des infos sur le systeme
logger.debug( "pluzzdl %s avec Python %s (%s)" % ( __version__, platform.python_version(), platform.machine() ) )
logger.debug( "OS : %s %s" % ( platform.system(), platform.version() ) )
# Verification de l'URL
if( ( re.match( "http://www.pluzz.fr/[^\.]+?\.html", args.urlEmission ) is None )
and
( re.match( "http://pluzz.francetv.fr/videos/[^\.]+?\.html", args.urlEmission ) is None )
):
logger.error( "L'URL \"%s\" n'est pas valide" % ( args.urlEmission ) )
sys.exit( -1 )
# Verification du proxy
if( args.proxy is not None ):
if( args.sock ):
if( re.match( '[0-9]+(?:\.[0-9]+){3}:[0-9]+', args.proxy ) is None ):
logger.error( "Le proxy SOCK \"%s\" n'est pas valide" % ( args.proxy ) )
sys.exit( -1 )
else:
if( re.match( "http://[^:]+?:\d+", args.proxy ) is None ):
logger.error( "Le proxy HTML \"%s\" n'est pas valide" % ( args.proxy ) )
sys.exit( -1 )
# Fonction d'affichage de l'avancement du téléchargement
if( args.progressbar ):
progressFnct = lambda x : logger.info( "Avancement : %3d %%" % ( x ) )
else:
progressFnct = lambda x : None
# Telechargement de la video
try:
PluzzDL( url = args.urlEmission,
proxy = args.proxy,
proxySock = args.sock,
sousTitres = args.soustitres,
progressFnct = progressFnct )
except PluzzDLException, e:
logger.critical( e )
sys.exit( -1 )
| Python |
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
# Notes :
# -> Filtre Wireshark :
# http.host contains "ftvodhdsecz" or http.host contains "francetv" or http.host contains "pluzz"
# ->
#
# Modules
#
import base64
import BeautifulSoup
import binascii
import datetime
import hashlib
import hmac
import os
import re
import StringIO
import struct
import threading
import time
import urllib
import urllib2
import xml.etree.ElementTree
import xml.sax
import zlib
from Configuration import Configuration
from Historique import Historique, Video
from Navigateur import Navigateur
import logging
logger = logging.getLogger( "pluzzdl" )
#
# Classes
#
class PluzzDL( object ):
"""
Classe principale pour lancer un telechargement
"""
REGEX_ID = "http://info.francetelevisions.fr/\?id-video=([^\"]+)"
XML_DESCRIPTION = "http://www.pluzz.fr/appftv/webservices/video/getInfosOeuvre.php?mode=zeri&id-diffusion=_ID_EMISSION_"
URL_SMI = "http://www.pluzz.fr/appftv/webservices/video/getFichierSmi.php?smi=_CHAINE_/_ID_EMISSION_.smi&source=azad"
M3U8_LINK = "http://medias2.francetv.fr/catchup-mobile/france-dom-tom/non-token/non-drm/m3u8/_FILE_NAME_.m3u8"
REGEX_M3U8 = "/([0-9]{4}/S[0-9]{2}/J[0-9]{1}/[0-9]*-[0-9]{6,8})-"
def __init__( self,
url, # URL de la video
proxy = None, # Proxy a utiliser
proxySock = False, # Indique si le proxy est de type SOCK
sousTitres = False, # Telechargement des sous-titres ?
progressFnct = lambda x : None, # Callback pour la progression du telechargement
stopDownloadEvent = threading.Event(), # Event pour arreter un telechargement
outDir = "." # Repertoire de sortie de la video telechargee
):
# Classe pour telecharger des fichiers
self.navigateur = Navigateur( proxy, proxySock )
# Infos video recuperees dans le XML
self.id = None
self.lienMMS = None
self.lienRTMP = None
self.manifestURL = None
self.m3u8URL = None
self.drm = None
self.chaine = None
self.timeStamp = None
self.codeProgramme = None
# Recupere l'id de l'emission
idEmission = self.getId( url )
# Recupere la page d'infos de l'emission
pageInfos = self.navigateur.getFichier( self.XML_DESCRIPTION.replace( "_ID_EMISSION_", idEmission ) )
# Parse la page d'infos
self.parseInfos( pageInfos )
# Petit message en cas de DRM
if( self.drm == "oui" ):
logger.warning( "La vidéo posséde un DRM ; elle sera sans doute illisible" )
# Verification qu'un lien existe
if( self.m3u8URL is None and
self.manifestURL is None and
self.lienRTMP is None and
self.lienMMS is None ):
raise PluzzDLException( "Aucun lien vers la vidéo" )
# Le telechargement se fait de differente facon selon le type du lien disponible
# Pour l'instant, seule la methode via les liens m3u8 fonctionne
# Le code pour les autres liens reste quand meme en place pour etre utilise si les elements manquants sont trouves (clef HMAC par exemple)
if( self.m3u8URL is not None ):
# Nom du fichier
nomFichier = self.getNomFichier( outDir, self.codeProgramme, self.timeStamp, "ts" )
# Downloader
downloader = PluzzDLM3U8( self.m3u8URL, nomFichier, self.navigateur, stopDownloadEvent, progressFnct )
elif( self.manifestURL is not None ):
# Nom du fichier
nomFichier = self.getNomFichier( outDir, self.codeProgramme, self.timeStamp, "flv" )
# Downloader
downloader = PluzzDLF4M( self.manifestURL, nomFichier, self.navigateur, stopDownloadEvent, progressFnct )
elif( self.lienRTMP is not None ):
# Downloader
downloader = PluzzDLRTMP( self.lienRTMP )
elif( self.lienMMS is not None ):
# Downloader
downloader = PluzzDLMMS( self.lienMMS )
# Recupere les sous titres si necessaire
if( sousTitres ):
self.telechargerSousTitres( idEmission, self.chaine, nomFichier )
# Lance le téléchargement
downloader.telecharger()
def getId( self, url ):
"""
Recupere l'ID de la video a partir de son URL
"""
try :
page = self.navigateur.getFichier( url )
idEmission = re.findall( self.REGEX_ID, page )[ 0 ]
logger.debug( "ID de l'émission : %s" % ( idEmission ) )
return idEmission
except :
raise PluzzDLException( "Impossible de récupérer l'ID de l'émission" )
def parseInfos( self, pageInfos ):
"""
Parse le fichier de description XML d'une emission
"""
try :
xml.sax.parseString( pageInfos, PluzzDLInfosHandler( self ) )
# Si le lien m3u8 n'existe pas, il faut essayer de creer celui de la plateforme mobile
if( self.m3u8URL is None ):
self.m3u8URL = self.M3U8_LINK.replace( "_FILE_NAME_", re.findall( self.REGEX_M3U8, pageInfos )[ 0 ] )
logger.debug( "URL m3u8 : %s" % ( self.m3u8URL ) )
logger.debug( "URL manifest : %s" % ( self.manifestURL ) )
logger.debug( "Lien RTMP : %s" % ( self.lienRTMP ) )
logger.debug( "Lien MMS : %s" % ( self.lienMMS ) )
logger.debug( "Utilisation de DRM : %s" % ( self.drm ) )
except :
raise PluzzDLException( "Impossible de parser le fichier XML de l'émission" )
def getNomFichier( self, repertoire, codeProgramme, timeStamp, extension ):
"""
Construit le nom du fichier de sortie
"""
return os.path.join( repertoire, "%s_%s.%s" % ( codeProgramme, datetime.datetime.fromtimestamp( timeStamp ).strftime( "%Y-%m-%d_%H-%M" ), extension ) )
def telechargerSousTitres( self, idEmission, nomChaine, nomVideo ):
"""
Recupere le fichier de sous titre de la video
"""
urlSousTitres = self.URL_SMI.replace( "_CHAINE_", nomChaine.lower().replace( " ", "" ) ).replace( "_ID_EMISSION_", idEmission )
# Essaye de recuperer le sous titre
try:
sousTitresSmi = self.navigateur.getFichier( urlSousTitres )
except:
logger.debug( "Sous titres indisponibles" )
return
logger.debug( "Sous titres disponibles" )
# Enregistre le fichier de sous titres en smi
try :
( nomFichierSansExtension, _ ) = os.path.splitext( nomVideo )
# Ecrit le fichier
with open( "%s.smi" % ( nomFichierSansExtension ), "w" ) as f:
f.write( sousTitresSmi )
except :
raise PluzzDLException( "Impossible d'écrire dans le répertoire %s" % ( os.getcwd() ) )
logger.debug( "Fichier de sous titre smi enregistré" )
# Convertit le fichier de sous titres en srt
try:
with open( "%s.srt" % ( nomFichierSansExtension ), "w" ) as f:
pageSoup = BeautifulSoup.BeautifulSoup( sousTitresSmi )
elmts = pageSoup.findAll( "sync" )
indice = 1
for ( elmtDebut, elmtFin ) in ( elmts[ i : i + 2 ] for i in range( 0, len( elmts ), 2 ) ):
# Extrait le temps de debut et le texte
tempsEnMs = int( elmtDebut[ "start" ] )
tempsDebutSrt = time.strftime( "%H:%M:%S,XXX", time.gmtime( int( tempsEnMs / 1000 ) ) )
tempsDebutSrt = tempsDebutSrt.replace( "XXX", str( tempsEnMs )[ -3 : ] )
lignes = elmtDebut.p.findAll( "span" )
texte = "\n".join( map( lambda x : x.contents[ 0 ].strip(), lignes ) )
# Extrait le temps de fin
tempsEnMs = int( elmtFin[ "start" ] )
tempsFinSrt = time.strftime( "%H:%M:%S,XXX", time.gmtime( int( tempsEnMs / 1000 ) ) )
tempsFinSrt = tempsFinSrt.replace( "XXX", str( tempsEnMs )[ -3 : ] )
# Ecrit dans le fichier
f.write( "%d\n" % ( indice ) )
f.write( "%s --> %s\n" % ( tempsDebutSrt, tempsFinSrt ) )
f.write( "%s\n\n" % ( texte.encode( "iso-8859-1" ) ) )
# Element suivant
indice += 1
except:
logger.error( "Impossible de convertir les sous titres en str" )
return
logger.debug( "Fichier de sous titre srt enregistré" )
class PluzzDLException( Exception ):
"""
Exception levee par PluzzDL
"""
pass
class PluzzDLM3U8( object ):
"""
Telechargement des liens m3u8
"""
def __init__( self, m3u8URL, nomFichier, navigateur, stopDownloadEvent, progressFnct ):
self.m3u8URL = m3u8URL
self.nomFichier = nomFichier
self.navigateur = navigateur
self.stopDownloadEvent = stopDownloadEvent
self.progressFnct = progressFnct
self.historique = Historique()
self.nomFichierFinal = "%s.mkv" % ( self.nomFichier[ :-3 ] )
def ouvrirNouvelleVideo( self ):
"""
Creer une nouvelle video
"""
try :
# Ouverture du fichier
self.fichierVideo = open( self.nomFichier, "wb" )
except :
raise PluzzDLException( "Impossible d'écrire dans le répertoire %s" % ( os.getcwd() ) )
# Ajout de l'en-tête
# Fait dans creerMKV
def ouvrirVideoExistante( self ):
"""
Ouvre une video existante
"""
try :
# Ouverture du fichier
self.fichierVideo = open( self.nomFichier, "a+b" )
except :
raise PluzzDLException( "Impossible d'écrire dans le répertoire %s" % ( os.getcwd() ) )
def creerMKV( self ):
"""
Creer un mkv a partir de la video existante (cree l'en-tete de la video)
"""
logger.info( "Création du fichier MKV (vidéo finale) ; veuillez attendre quelques instants" )
try:
if( os.name == "nt" ):
commande = "ffmpeg.exe -i %s -vcodec copy -acodec copy %s 1>NUL 2>NUL" % ( self.nomFichier, self.nomFichierFinal )
else:
commande = "ffmpeg -i %s -vcodec copy -acodec copy %s 1>/dev/null 2>/dev/null" % ( self.nomFichier, self.nomFichierFinal )
if( os.system( commande ) == 0 ):
os.remove( self.nomFichier )
logger.info( "Fin !" )
else:
logger.warning( "Problème lors de la création du MKV avec FFmpeg ; le fichier %s est néanmoins disponible" % ( self.nomFichier ) )
except:
raise PluzzDLException( "Impossible de créer la vidéo finale" )
def telecharger( self ):
# Recupere le fichier master.m3u8
self.m3u8 = self.navigateur.getFichier( self.m3u8URL )
# Extrait l'URL de base pour tous les fragments
self.urlBase = "/".join( self.m3u8URL.split( "/" )[ :-1 ] )
# Recupere le lien avec le plus gros bitrate
try:
self.listeFragmentsURL = "%s/%s" % ( self.urlBase, re.findall( ".+?\.m3u8.*", self.m3u8 )[ -1 ] )
except:
raise PluzzDLException( "Impossible de trouver le lien vers la liste des fragments" )
# Recupere la liste des fragments
self.listeFragmentsPage = self.navigateur.getFichier( self.listeFragmentsURL )
# Extrait l'URL de tous les fragments
self.listeFragments = re.findall( ".+?\.ts", self.listeFragmentsPage )
#
# Creation de la video
#
self.premierFragment = 1
self.telechargementFini = False
video = self.historique.getVideo( self.listeFragmentsURL )
# Si la video est dans l'historique
if( video is not None ):
# Si la video existe sur le disque
if( os.path.exists( self.nomFichier ) or os.path.exists( self.nomFichierFinal ) ):
if( video.finie ):
logger.info( "La vidéo a déjà été entièrement téléchargée" )
if( not os.path.exists( self.nomFichierFinal ) ):
self.creerMKV()
return
else:
self.ouvrirVideoExistante()
self.premierFragment = video.fragments
logger.info( "Reprise du téléchargement de la vidéo au fragment %d" % ( video.fragments ) )
else:
self.ouvrirNouvelleVideo()
logger.info( u"Impossible de reprendre le téléchargement de la vidéo, le fichier %s n'existe pas" % ( self.nomFichier ) )
else: # Si la video n'est pas dans l'historique
self.ouvrirNouvelleVideo()
# Nombre de fragments
self.nbFragMax = float( len( self.listeFragments ) )
logger.debug( "Nombre de fragments : %d" % ( self.nbFragMax ) )
# Ajout des fragments
logger.info( "Début du téléchargement des fragments" )
try :
i = self.premierFragment
while( i <= self.nbFragMax and not self.stopDownloadEvent.isSet() ):
frag = self.navigateur.getFichier( "%s/%s" % ( self.urlBase, self.listeFragments[ i - 1 ] ) )
self.fichierVideo.write( frag )
# Affichage de la progression
self.progressFnct( min( int( ( i / self.nbFragMax ) * 100 ), 100 ) )
i += 1
if( i == self.nbFragMax + 1 ):
self.progressFnct( 100 )
self.telechargementFini = True
logger.info( "Fin du téléchargement" )
self.creerMKV()
except KeyboardInterrupt:
logger.info( "Interruption clavier" )
except:
logger.critical( "Erreur inconnue" )
finally :
# Ajout dans l'historique
self.historique.ajouter( Video( lien = self.listeFragmentsURL, fragments = i, finie = self.telechargementFini ) )
# Fermeture du fichier
self.fichierVideo.close()
class PluzzDLF4M( object ):
"""
Telechargement des liens f4m
"""
adobePlayer = "http://fpdownload.adobe.com/strobe/FlashMediaPlayback_101.swf"
def __init__( self, manifestURL, nomFichier, navigateur, stopDownloadEvent, progressFnct ):
self.manifestURL = manifestURL
self.nomFichier = nomFichier
self.navigateur = navigateur
self.stopDownloadEvent = stopDownloadEvent
self.progressFnct = progressFnct
self.historique = Historique()
self.configuration = Configuration()
self.hmacKey = self.configuration[ "hmac_key" ].decode( "hex" )
self.playerHash = self.configuration[ "player_hash" ]
def parseManifest( self ):
"""
Parse le manifest
"""
try :
arbre = xml.etree.ElementTree.fromstring( self.manifest )
# Duree
self.duree = float( arbre.find( "{http://ns.adobe.com/f4m/1.0}duration" ).text )
self.pv2 = arbre.find( "{http://ns.adobe.com/f4m/1.0}pv-2.0" ).text
media = arbre.findall( "{http://ns.adobe.com/f4m/1.0}media" )[ -1 ]
# Bitrate
self.bitrate = int( media.attrib[ "bitrate" ] )
# URL des fragments
urlbootstrap = media.attrib[ "url" ]
self.urlFrag = "%s%sSeg1-Frag" % ( self.manifestURLToken[ : self.manifestURLToken.find( "manifest.f4m" ) ], urlbootstrap )
# Header du fichier final
self.flvHeader = base64.b64decode( media.find( "{http://ns.adobe.com/f4m/1.0}metadata" ).text )
except :
raise PluzzDLException( "Impossible de parser le manifest" )
def ouvrirNouvelleVideo( self ):
"""
Creer une nouvelle video
"""
try :
# Ouverture du fichier
self.fichierVideo = open( self.nomFichier, "wb" )
except :
raise PluzzDLException( "Impossible d'écrire dans le répertoire %s" % ( os.getcwd() ) )
# Ajout de l'en-tête FLV
self.fichierVideo.write( binascii.a2b_hex( "464c56010500000009000000001200010c00000000000000" ) )
# Ajout de l'header du fichier
self.fichierVideo.write( self.flvHeader )
self.fichierVideo.write( binascii.a2b_hex( "00000000" ) ) # Padding pour avoir des blocs de 8
def ouvrirVideoExistante( self ):
"""
Ouvre une video existante
"""
try :
# Ouverture du fichier
self.fichierVideo = open( self.nomFichier, "a+b" )
except :
raise PluzzDLException( "Impossible d'écrire dans le répertoire %s" % ( os.getcwd() ) )
def decompressSWF( self, swfData ):
"""
Decompresse un fichier swf
"""
# Adapted from :
# Prozacgod
# http://www.python-forum.org/pythonforum/viewtopic.php?f=2&t=14693
if( type( swfData ) is str ):
swfData = StringIO.StringIO( swfData )
swfData.seek( 0, 0 )
magic = swfData.read( 3 )
if( magic == "CWS" ):
return "FWS" + swfData.read( 5 ) + zlib.decompress( swfData.read() )
else:
return None
def getPlayerHash( self ):
"""
Recupere le sha256 du player flash
"""
# Get SWF player
playerData = self.navigateur.getFichier( "http://static.francetv.fr/players/Flash.H264/player.swf" )
# Uncompress SWF player
playerDataUncompress = self.decompressSWF( playerData )
# Perform sha256 of uncompressed SWF player
hashPlayer = hashlib.sha256( playerDataUncompress ).hexdigest()
# Perform base64
return base64.encodestring( hashPlayer.decode( 'hex' ) )
def debutVideo( self, fragID, fragData ):
"""
Trouve le debut de la video dans un fragment
"""
# Skip fragment header
start = fragData.find( "mdat" ) + 4
# For all fragment (except frag1)
if( fragID > 1 ):
# Skip 2 FLV tags
for dummy in range( 2 ):
tagLen, = struct.unpack_from( ">L", fragData, start ) # Read 32 bits (big endian)
tagLen &= 0x00ffffff # Take the last 24 bits
start += tagLen + 11 + 4 # 11 = tag header len ; 4 = tag footer len
return start
def telecharger( self ):
# Verifie si le lien du manifest contient la chaine "media-secure"
if( self.manifestURL.find( "media-secure" ) != -1 ):
raise PluzzDLException( "pluzzdl ne sait pas gérer ce type de vidéo (utilisation de DRMs)..." )
# Lien du manifest (apres le token)
self.manifestURLToken = self.navigateur.getFichier( "http://hdfauth.francetv.fr/esi/urltokengen2.html?url=%s" % ( self.manifestURL[ self.manifestURL.find( "/z/" ) : ] ) )
# Recupere le manifest
self.manifest = self.navigateur.getFichier( self.manifestURLToken )
# Parse le manifest
self.parseManifest()
# Calcul les elements
self.hdnea = self.manifestURLToken[ self.manifestURLToken.find( "hdnea" ) : ]
self.pv20, self.hdntl = self.pv2.split( ";" )
self.pvtokenData = r"st=0000000000~exp=9999999999~acl=%2f%2a~data=" + self.pv20 + "!" + self.playerHash
self.pvtoken = "pvtoken=%s~hmac=%s" % ( urllib.quote( self.pvtokenData ), hmac.new( self.hmacKey, self.pvtokenData, hashlib.sha256 ).hexdigest() )
#
# Creation de la video
#
self.premierFragment = 1
self.telechargementFini = False
video = self.historique.getVideo( self.urlFrag )
# Si la video est dans l'historique
if( video is not None ):
# Si la video existe sur le disque
if( os.path.exists( self.nomFichier ) ):
if( video.finie ):
logger.info( "La vidéo a déjà été entièrement téléchargée" )
return
else:
self.ouvrirVideoExistante()
self.premierFragment = video.fragments
logger.info( "Reprise du téléchargement de la vidéo au fragment %d" % ( video.fragments ) )
else:
self.ouvrirNouvelleVideo()
logger.info( "Impossible de reprendre le téléchargement de la vidéo, le fichier %s n'existe pas" % ( self.nomFichier ) )
else: # Si la video n'est pas dans l'historique
self.ouvrirNouvelleVideo()
# Calcul l'estimation du nombre de fragments
self.nbFragMax = round( self.duree / 6 )
logger.debug( "Estimation du nombre de fragments : %d" % ( self.nbFragMax ) )
# Ajout des fragments
logger.info( "Début du téléchargement des fragments" )
try :
i = self.premierFragment
self.navigateur.appendCookie( "hdntl", self.hdntl )
while( not self.stopDownloadEvent.isSet() ):
# frag = self.navigateur.getFichier( "%s%d?%s&%s&%s" %( self.urlFrag, i, self.pvtoken, self.hdntl, self.hdnea ) )
frag = self.navigateur.getFichier( "%s%d" % ( self.urlFrag, i ), referer = self.adobePlayer )
debut = self.debutVideo( i, frag )
self.fichierVideo.write( frag[ debut : ] )
# Affichage de la progression
self.progressFnct( min( int( ( i / self.nbFragMax ) * 100 ), 100 ) )
i += 1
except urllib2.URLError, e :
if( hasattr( e, 'code' ) ):
if( e.code == 403 ):
if( e.reason == "Forbidden" ):
logger.info( "Le hash du player semble invalide ; calcul du nouveau hash" )
newPlayerHash = self.getPlayerHash()
if( newPlayerHash != self.playerHash ):
self.configuration[ "player_hash" ] = newPlayerHash
self.configuration.writeConfig()
logger.info( "Un nouveau hash a été trouvé ; essayez de relancer l'application" )
else:
logger.critical( "Pas de nouveau hash disponible..." )
else:
logger.critical( "Impossible de charger la vidéo" )
elif( e.code == 404 ):
self.progressFnct( 100 )
self.telechargementFini = True
logger.info( "Fin du téléchargement" )
except KeyboardInterrupt:
logger.info( "Interruption clavier" )
except:
logger.critical( "Erreur inconnue" )
finally :
# Ajout dans l'historique
self.historique.ajouter( Video( lien = self.urlFrag, fragments = i, finie = self.telechargementFini ) )
# Fermeture du fichier
self.fichierVideo.close()
class PluzzDLRTMP( object ):
"""
Telechargement des liens rtmp
"""
def __init__( self, lienRTMP ):
self.lien = lienRTMP
def telecharger( self ):
logger.info( "Lien RTMP : %s\nUtiliser par exemple rtmpdump pour la recuperer directement" % ( self.lien ) )
class PluzzDLMMS( object ):
"""
Telechargement des liens mms
"""
def __init__( self, lienMMS ):
self.lien = lienMMS
def telecharger( self ):
logger.info( "Lien MMS : %s\nUtiliser par exemple mimms ou msdl pour la recuperer directement" % ( self.lien ) )
class PluzzDLInfosHandler( xml.sax.handler.ContentHandler ):
"""
Handler pour parser le XML de description d'une emission
"""
def __init__( self, pluzzdl ):
self.pluzzdl = pluzzdl
self.isUrl = False
self.isDRM = False
self.isChaine = False
self.isCodeProgramme = False
def startElement( self, name, attrs ):
if( name == "url" ):
self.isUrl = True
elif( name == "drm" ):
self.isDRM = True
elif( name == "chaine" ):
self.isChaine = True
elif( name == "diffusion" ):
self.pluzzdl.timeStamp = float( attrs.getValue( "timestamp" ) )
elif( name == "code_programme" ):
self.isCodeProgramme = True
def characters( self, data ):
if( self.isUrl ):
if( data[ : 3 ] == "mms" ):
self.pluzzdl.lienMMS = data
elif( data[ : 4 ] == "rtmp" ):
self.pluzzdl.lienRTMP = data
elif( data[ -3 : ] == "f4m" ):
self.pluzzdl.manifestURL = data
elif( data[ -4 : ] == "m3u8" ):
self.pluzzdl.m3u8URL = data
elif( self.isDRM ):
self.pluzzdl.drm = data
elif( self.isChaine ):
self.pluzzdl.chaine = data
elif( self.isCodeProgramme ):
self.pluzzdl.codeProgramme = data
def endElement( self, name ):
if( name == "url" ):
self.isUrl = False
elif( name == "drm" ):
self.isDRM = False
elif( name == "chaine" ):
self.isChaine = False
elif( name == "code_programme" ):
self.isCodeProgramme = False
| 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)-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
#
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 -*-
#
# Infos
#
__author__ = "Chaoswizard"
__license__ = "GPL 2"
__version__ = "0.9.3"
__url__ = "http://code.google.com/p/tvdownloader/"
#
# Modules
#
import os
import sys
from PyQt4 import QtCore
from PyQt4 import QtGui
from MainWindow import MainWindow
#
# Main
#
if( __name__ == "__main__" ) :
# Creation des repertoires de travail
if( os.name == "nt" ):
pluzzdlDirs = [ "Videos" ]
else:
pluzzdlDirs = [ os.path.join( os.path.expanduser( "~" ), "pluzzdl" ) ]
for pluzzdlDir in pluzzdlDirs:
if( not os.path.isdir( pluzzdlDir ) ):
os.makedirs( pluzzdlDir )
# Lancement de la GUI
app = QtGui.QApplication( sys.argv )
window = MainWindow( __version__ )
window.show()
sys.exit( app.exec_() )
| 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 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
#
import logging
import os
import re
import sys
sys.path.append( ".." )
import threading
from PyQt4 import QtCore
from PyQt4 import QtGui
from PluzzDL import PluzzDL
import ressources
from QtLogHandler import QtLogHandler
from QtLogWidget import QtLogWidget
from QtString import stringToQstring
from QtString import qstringToString
#
# Class
#
class MainWindow( QtGui.QMainWindow ):
def __init__( self, pluzzdlVersion ):
QtGui.QMainWindow.__init__( self )
# App icons
self.tvdIcon = QtGui.QIcon( ":/ico/tvdownloader.png" )
self.startIcon = QtGui.QIcon( ":/ico/gtk-media-play-ltr.png" )
self.stopIcon = QtGui.QIcon( ":/ico/gtk-media-stop.png" )
self.folderIcon = QtGui.QIcon( ":/ico/gtk-folder.png" )
# Main window properties
self.setWindowTitle( "pluzzdl %s" % ( pluzzdlVersion ) )
self.setWindowIcon( self.tvdIcon )
self.resize( 570, 210 )
# Central widget
self.centralWidget = QtGui.QWidget( self )
# URL label
self.urlLabel = QtGui.QLabel( "Entrer une URL valide :", self.centralWidget )
# Line edit
self.urlLineEdit = QtGui.QLineEdit( self.centralWidget )
# Progress bar
self.downloadProgressBar = QtGui.QProgressBar( self.centralWidget )
self.downloadProgressBar.setValue( 0 )
self.downloadProgressBar.setMaximum( 100 )
# self.downloadProgressBar.setTextVisible( False )
# Start/stop button
self.startStopPushButton = QtGui.QPushButton( self.startIcon, "Start", self.centralWidget )
self.startStopPushButton.setEnabled( False )
self.downloadInProgress = False
# Open video folder button
self.videoPushButton = QtGui.QPushButton( self.folderIcon, "Ouvrir", self.centralWidget )
# Proxy label
self.proxyLabel = QtGui.QLabel( u"Proxy a utiliser :", self.centralWidget )
# Text zone for proxy
self.proxyLineEdit = QtGui.QLineEdit( self.centralWidget )
self.proxyLineEdit.setToolTip( u"Proxy HTTP au format http://URL:PORT ou proxy SOCK5 au format ADRESSE:PORT" )
# Logger
self.logWidget = QtLogWidget( self )
# Add all widgets to a grid layout
self.gridLayout = QtGui.QGridLayout( self.centralWidget )
self.gridLayout.addWidget( self.urlLabel, 0, 0, 1, 1 )
self.gridLayout.addWidget( self.urlLineEdit, 0, 1, 1, 3 )
self.gridLayout.addWidget( self.proxyLabel, 1, 0, 1, 1 )
self.gridLayout.addWidget( self.proxyLineEdit, 1, 1, 1, 3 )
self.gridLayout.addWidget( self.downloadProgressBar, 2, 0, 1, 2 )
self.gridLayout.addWidget( self.startStopPushButton, 2, 2, 1, 1 )
self.gridLayout.addWidget( self.videoPushButton, 2, 3, 1, 1 )
self.gridLayout.addWidget( self.logWidget, 3, 0, 1, 4 )
# Set central widget
self.setCentralWidget( self.centralWidget )
# Set logger
logger = logging.getLogger( "pluzzdl" )
logger.setLevel( logging.INFO )
self.logHandler = QtLogHandler( self.logWidget )
logger.addHandler( self.logHandler )
# Signals
QtCore.QObject.connect( self.urlLineEdit,
QtCore.SIGNAL( "textChanged(QString)" ),
self.checkUrl )
QtCore.QObject.connect( self.startStopPushButton,
QtCore.SIGNAL( "clicked()" ),
self.startStopDownload )
QtCore.QObject.connect( self.videoPushButton,
QtCore.SIGNAL( "clicked()" ),
self.openVideoFolder )
QtCore.QObject.connect( self,
QtCore.SIGNAL( "updateProgressBar(int)" ),
self.downloadProgressBar.setValue )
QtCore.QObject.connect( self,
QtCore.SIGNAL( "stopDownload()" ),
self.stopDownload )
self.downloadThread = None
self.stopDownloadEvent = threading.Event()
if( os.name == "nt" ):
self.downloadDir = "Videos"
else:
self.downloadDir = os.path.join( os.path.expanduser( "~" ), "pluzzdl" )
def closeEvent( self, evt ):
if( self.downloadInProgress is True ):
self.stopDownload()
evt.accept()
def checkUrl( self, url ):
if( ( re.match( "http://www.pluzz.fr/[^\.]+?\.html", url ) is None )
and
( re.match( "http://pluzz.francetv.fr/videos/[^\.]+?\.html", url ) is None )
):
self.startStopPushButton.setEnabled( False )
else:
self.startStopPushButton.setEnabled( True )
def startStopDownload( self ):
if( self.downloadInProgress is True ):
self.stopDownload()
else:
self.startDownload()
def startDownload( self ):
def dlVideo( url, proxy, sock ):
try:
PluzzDL( url = url,
proxy = proxy,
proxySock = sock,
progressFnct = self.updateProgressBar,
stopDownloadEvent = self.stopDownloadEvent,
sousTitres = True,
outDir = self.downloadDir )
except:
pass
self.emit( QtCore.SIGNAL( "stopDownload()" ) )
# Retrieve proxy
proxySock = False
proxyString = qstringToString( self.proxyLineEdit.text() )
if( len( proxyString ) == 0 ):
proxyString = None
elif( proxyString[ : 4 ] != "http" ):
proxySock = True
#
self.stopDownloadEvent.clear()
self.downloadThread = threading.Thread( target = dlVideo, args = ( qstringToString( self.urlLineEdit.text() ), proxyString, proxySock ) )
self.downloadThread.start()
self.downloadInProgress = True
self.updateButtons()
def stopDownload( self ):
self.stopDownloadEvent.set()
self.downloadThread.join()
self.downloadInProgress = False
self.updateButtons()
def updateButtons( self ):
if( self.downloadInProgress ):
self.startStopPushButton.setIcon( self.stopIcon )
self.startStopPushButton.setText( "Stop" )
else:
self.startStopPushButton.setIcon( self.startIcon )
self.startStopPushButton.setText( "Start" )
def openVideoFolder( self ):
QtGui.QDesktopServices.openUrl( QtCore.QUrl.fromLocalFile( self.downloadDir ) )
def updateProgressBar( self, value ):
self.emit( QtCore.SIGNAL( "updateProgressBar(int)" ), 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 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 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 = 15
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, data = None ):
logger.info( "acces a la page %s" %( URLPage ) )
try:
# Page a charger
if( data is not None ):
req = mechanize.Request( URLPage, urllib.urlencode( data ) )
page = mechanize.urlopen( req )
else:
page = self.navigateur.open( URLPage, timeout = self.timeOut )
return page.read()
# 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 ):
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 = re.sub( r'\&\#(x?[0-9a-fA-F]+);', ent2chr, texte )
return texte
#~ n = Navigateur()
#~
#~ print n.getPages( [ "http://effbot.org/zone/thread-synchronization.htm",
#~ "http://www.google.fr/" ] )
| 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( "Telechargement 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" ):
if( fichier.find( "swfVfy" ) == -1 ):
commande = urlToRtmpdump( fichier )
else:
commande = "rtmpdump -r " + 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__ )
##########
# 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
path = os.path.expanduser( "~" )
self.fichierConfiguration = path+"/.tvdownloader/conf/"+self.nom.replace( " ", "_" )+".conf"
self.fichierCache = path+"/.tvdownloader/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__ )
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.home = os.path.expanduser( "~" )
self.fichierConfiguration = self.home + "/.tvdownloader/conf/tvdownloader"
self.chargerConfiguration()
## Methode qui charge les preferences du logiciel
def chargerConfiguration( self ):
# Parametres par defaut
self.preferencesParDefault = { "repertoireTelechargement" : self.home + "/TVDownloader",
"pluginsActifs" : [],
"pluginParDefaut" : "",
"tailleFenetre" : [ 500, 500 ],
"timeOut" : 5,
"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 certaines preferences du logiciel
# Seuls les preferences des classes qui utilise le singleton sont applquees
def appliquerPreferences( self ):
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 sys
import os
import optparse
import logging
#
# Entree du programme
#
if __name__ == "__main__" :
# 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( "" )
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
home = os.path.expanduser( "~" )
repertoires = [ "/.tvdownloader/cache", \
"/.tvdownloader/conf", \
"/.tvdownloader/logs", \
"/.tvdownloader/plugins" ]
for repertoire in repertoires:
rep = home + repertoire
if( not os.path.isdir( rep ) ):
logger.info( "création du répertoire %s" %( rep ) )
os.makedirs( rep )
# 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
# 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 |
#!/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, data = None ):
return self.navigateur.getPage( url, data )
#~
#~ #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 ""
## 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 -*-
#
# Modules
#
import BeautifulSoup
import os
import unicodedata
from Fichier import Fichier
from Plugin import Plugin
#
# Classe
#
class LCP( Plugin ):
pageEmissions = "http://www.lcp.fr/videos/emissions"
listeEmissions = {} # { Nom emission, id de l'emission sur le site }
def __init__( self ):
Plugin.__init__( self, "La Chaine Parlementaire", "http://www.lcp.fr/", 7 )
if( os.path.exists( self.fichierCache ) ):
self.listeEmissions = self.chargerCache()
def rafraichir( self ):
self.afficher( u"Récupération de la liste des émissions..." )
# RAZ
self.listeEmissions.clear()
# Recupere la page principale
page = self.API.getPage( self.pageEmissions )
soupStrainer = BeautifulSoup.SoupStrainer( "div", { "class" : "unit size1of5" } )
pageSoup = BeautifulSoup.BeautifulSoup( page, parseOnlyThese = soupStrainer )
# Extrait les emissions
for emissionBlock in pageSoup.contents:
try:
nomEmission = unicodedata.normalize( 'NFKD', emissionBlock.div.p.a[ "title" ] ).encode( 'ASCII', 'ignore' )
idEmission = emissionBlock.div.p.input[ "value" ]
self.listeEmissions[ nomEmission ] = idEmission
except:
continue
self.sauvegarderCache( self.listeEmissions )
self.afficher( u"Liste des émissions sauvegardées" )
def listerChaines( self ):
self.ajouterChaine( self.nom )
def listerEmissions( self, chaine ):
for emission in self.listeEmissions.keys():
self.ajouterEmission( chaine, emission )
def listerFichiers( self, emission ):
if( self.listeEmissions.has_key( emission ) ):
# Recupere la page qui liste les fichiers
pageFichiers = self.API.getPage( "http://www.lcp.fr/spip.php?page=lcp_page_videos_ajax&parent=%s" %( self.listeEmissions[ emission ] ) )
soupStrainer = BeautifulSoup.SoupStrainer( "div", { "class" : "video-item" } )
pageFichiersSoup = BeautifulSoup.BeautifulSoup( pageFichiers, parseOnlyThese = soupStrainer )
# Extrait d'abord tous les liens vers les pages qui contienent les fichiers
listeUrls = map( lambda x : "http://www.lcp.fr/%s" %( x[ "href" ] ), pageFichiersSoup.findAll( "a" ) )
# Recupere toutes les pages
dicoPageFichier = self.API.getPages( listeUrls )
# Extrait les fichiers
for fichiersBlock in pageFichiersSoup.contents:
try:
urlPageFichier = "http://www.lcp.fr/%s" %( fichiersBlock.strong.a[ "href" ] )
urlImage = "http://www.lcp.fr/%s" %( fichiersBlock.strong.img[ "src" ] )
descriptif = fichiersBlock.p.contents[ 0 ].replace( "\n", "" ).replace( "\t", "" )
pageFichier = dicoPageFichier[ urlPageFichier ]
if( pageFichier == "" ):
continue
soup = BeautifulSoup.BeautifulSoup( pageFichier )
#
# Code k3c
#
nom = urlPageFichier.split('/')[-1:][0]
player = soup.find('param', {'name': 'movie'})['value']
info_video = soup.find('param', attrs={'name' : 'flashvars' })['value']
host = info_video.split('rtmp://')[1].split('/')[0]
app = info_video.split('rtmp://')[1].split('/')[1]
s2 = host+"/"+app+"/"
playpath = info_video.split(s2)[1].split('/mp4')[0]
playpath = playpath[:-4]
cmds = "rtmpdump"+" --resume --live 0 --host "+host+" --swfVfy "+ player+" --swfAge 0 -v --app "+app+" --playpath "+playpath+" -e -k 1 --flv "+str(nom)+".mp4"
#
# Fin code k3c
#
# Ajouter le fichier
self.ajouterFichier( emission, Fichier( nom = "%s - %s" %( emission, descriptif ), lien = cmds, nomFichierSortie = "%s %s.mp4" %( emission, descriptif ), urlImage = urlImage, descriptif = descriptif ) )
except:
continue
| 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 -*-
#
# Modules
#
import BeautifulSoup
import os
import unicodedata
from Fichier import Fichier
from Plugin import Plugin
#
# Classe
#
class PublicSenat( Plugin ):
pageEmissions = "http://www.publicsenat.fr/cms/video-a-la-demande/vod.html"
listeEmissions = {} # { Nom emission, id de l'emission sur le site }
def __init__( self ):
Plugin.__init__( self, "Public Senat", "http://www.publicsenat.fr", 7 )
if( os.path.exists( self.fichierCache ) ):
self.listeEmissions = self.chargerCache()
def rafraichir( self ):
self.afficher( u"Récupération de la liste des émissions..." )
# RAZ
self.listeEmissions.clear()
# Recupere la page principale
page = self.API.getPage( self.pageEmissions )
soupStrainer = BeautifulSoup.SoupStrainer( "option", { "value" : True } )
pageSoup = BeautifulSoup.BeautifulSoup( page, parseOnlyThese = soupStrainer )
# Extrait les emissions
for emissionBlock in pageSoup.contents[ 1 : ]:
try:
nomEmission = unicodedata.normalize( 'NFKD', emissionBlock.string.title() ).encode( 'ASCII', 'ignore' )
idEmission = emissionBlock[ "value" ]
self.listeEmissions[ nomEmission ] = idEmission
except:
continue
self.sauvegarderCache( self.listeEmissions )
self.afficher( u"Liste des émissions sauvegardées" )
def listerChaines( self ):
self.ajouterChaine( self.nom )
def listerEmissions( self, chaine ):
for emission in self.listeEmissions.keys():
self.ajouterEmission( chaine, emission )
def listerFichiers( self, emission ):
#
# TODO : parcourir toutes les pages
#
if( self.listeEmissions.has_key( emission ) ):
# Recupere la page qui liste les fichiers
pageFichiers = self.API.getPage( "http://www.publicsenat.fr/zp/templates/emission/JX_video.php", { "idP" : self.listeEmissions[ emission ], "page" : 1 } )
pageFichiersSoup = BeautifulSoup.BeautifulSoup( pageFichiers )
# Fichiers
fichiersBlock = pageFichiersSoup.findAll( "div", { "class" : "box-bg" } )
# Extrait d'abord tous les liens vers les pages qui contienent les fichiers
listeUrls = map( lambda x : "http://www.publicsenat.fr%s" %( x.div.a[ "href" ] ), fichiersBlock )
# Recupere toutes les pages
dicoPageFichier = self.API.getPages( listeUrls )
# Extrait les fichiers
for fichier in fichiersBlock:
try:
urlPageFichier = "http://www.publicsenat.fr%s" %( fichier.div.a[ "href" ] )
urlImage = "http://www.publicsenat.fr%s" %( fichier.div.a.img[ "src" ] )
descriptif = fichier.h3.a.string
pageFichier = dicoPageFichier[ urlPageFichier ]
if( pageFichier == "" ):
continue
# Extrait le lien vers la video
fichierSoup = BeautifulSoup.BeautifulSoup( pageFichier )
lienVideo = fichierSoup.find( "input", { "id" : "flvEmissionSelect" } )[ "value" ]
# Ajouter le fichier
self.ajouterFichier( emission, Fichier( nom = descriptif, lien = lienVideo, urlImage = urlImage, descriptif = descriptif ) )
except:
continue
| 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"
},
"RTL" : { u"Grosse Tetes" : "http://www.rtl.fr/podcast/les-grosses-tetes.xml",
u"Laurent Gerra" :
"http://www.rtl.fr/podcast/laurent-gerra.xml",
u"A la bonne heure" :
"http://www.rtl.fr/podcast/a-la-bonne-heure.xml",
u"l heure du crime" :
"http://www.rtl.fr/podcast/l-heure-du-crime.xml",
u"l invite de rtl" :
"http://www.rtl.fr/podcast/linvite-de-rtl.xml",
u"z comme zemmour" :
"http://www.rtl.fr/podcast/z-comme-zemmour.xml",
u"Ca peut vous arriver" :
"http://www.rtl.fr/podcast/ca-peut-vous-arriver.xml",
u"le club liza.xml" :
"http://www.rtl.fr/podcast/le-club-liza.xml",
u"face a face aphatie duhamel en video" :
"http://www.rtl.fr/podcast/face-a-face-aphatie-duhamel-en-video.xml.xml",
u"La marque du mailhot" :
"http://www.rtl.fr/podcast/la-marque-du-mailhot.xml",
u"Le choix de yves calvi" :
"http://www.rtl.fr/podcast/le-choix-de-yves-calvi.xml",
u"Le choix de yves calvi en video" :
"http://www.rtl.fr/podcast/le-choix-de-yves-calvi-en-video.xml",
u"le grand jury" :
"http://www.rtl.fr/podcast/le-grand-jury.xml",
u"le journal inattendu" :
"http://www.rtl.fr/podcast/le-journal-inattendu.xml",
u"le fait politique" :
"http://www.rtl.fr/podcast/le-fait-politique.xml",
u"on est fait pour s entendre" :
"http://www.rtl.fr/podcast/on-est-fait-pour-s-entendre.xml",
u"a-la-bonne-heure didier porte" :
"http://www.rtl.fr/podcast/a-la-bonne-heure-didier-porte.xml",
u"on refait le match - Christophe Pacaud" :
"http://www.rtl.fr/podcast/on-refait-le-match-avec-christophe-pacaud.xml",
u"on refait le match - Eugene Saccomano" :
"http://www.rtl.fr/podcast/on-refait-le-match-avec-eugene-saccomano.xml",
u"a-la-bonne-heure Eric Naulleau" :
"http://www.rtl.fr/podcast/a-la-bonne-heure-eric-naulleau.xml",
u"a-la-bonne-heure Eric Naulleau en video" :
"http://www.rtl.fr/podcast/a-la-bonne-heure-eric-naulleau-en-video.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
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://groupemsix.fcod.llnwd.net/a2883/d1/mp4:production/regienum/" + lien +" --port 1935 --swfVfy http://groupemsix.rd.llnwd.net/u/players/ReplayPlayerV2Hds.swf --swfAge 0"
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 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://www.w9replay.fr/catalogue/3637.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:
nom = nom.replace( ".f4m", ".mp4" )
lien = lien.replace( ".f4m", ".mp4" )
lienValide = "rtmpe://groupemsix.fcod.llnwd.net/a2883/d1/mp4:production/w9replay/" + lien +" --port 1935 --swfVfy http://l3.player.M6.fr/swf/ReplayPlayerV2Hds.swf --swfAge 0"
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 -*-
#~ 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 ):
ulrListeEmission = "http://www.franceinter.fr/podcasts/liste-des-emissions"
listeEmissions = {} # { Nom emission, URL fichier XML }
pageRegEx = re.compile( 'class="visuel" title="([^"]*?)".+?href="(http://radiofrance-podcast.net/podcast09/.+?.xml)', re.DOTALL )
def __init__( self ):
Plugin.__init__( self, "France Inter", "http://www.franceinter.fr/podcasts", 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()
# On recupere la page web
page = self.API.getPage( self.ulrListeEmission )
# Extraction des emissions
self.listeEmissions = dict( re.findall( self.pageRegEx, page ) )
self.sauvegarderCache( self.listeEmissions )
self.afficher( u"Liste des émissions sauvegardées" )
def listerChaines( self ):
self.ajouterChaine( self.nom )
def listerEmissions( self, chaine ):
for emission in self.listeEmissions.keys():
self.ajouterEmission( chaine, emission )
def listerFichiers( self, emission ):
if( self.listeEmissions.has_key( emission ) ):
# On recupere la page web qui liste les fichiers
pageXML = self.API.getPage( self.listeEmissions[ 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 #
###########
# 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/svn/branches/MAJ_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("Erreur de chargement des préférences de"+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
from PyQt4 import QtGui, QtCore
from Preferences import Preferences
from PluginManager import PluginManager
from GUI.ConvertQString import *
from GUI.Signaux import Signaux
##########
# Classe #
##########
## Classe qui gere le dialog des preferences du logiciel
class PreferencesDialog( QtGui.QDialog ):
## Constructeur
# @param signaux Lanceur de signaux
def __init__( self, parent, signaux ):
# Appel au constructeur de la classe mere
QtGui.QDialog.__init__( self, parent )
self.preferences = Preferences()
self.pluginManager = PluginManager()
self.signaux = signaux
###########
# Fenetre #
###########
###
# Reglages de la fenetre principale
###
# Nom de la fenetre
self.setWindowTitle( u"Préférences" )
# Dimensions la fenetre
self.resize( 280, 340 )
# Mise en place de son icone
self.setWindowIcon( QtGui.QIcon( "ico/gtk-preferences.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 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 )
self.gridLayout.addWidget( self.buttonBox, 8, 0, 1, 2 )
###
# 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( 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.signaux.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
##########
# Classe #
##########
## Classe qui envoie differents signaux
class Signaux( QtCore.QObject ):
## Constructeur
def __init__( self ):
QtCore.QObject.__init__( self )
# Liste des signaux
self.listeSignaux = {
"actualiserListesDeroulantes" : QtCore.SIGNAL( "actualiserListesDeroulantes()" ),
"debutActualisation" : QtCore.SIGNAL( "debutActualisation(PyQt_PyObject)" ),
"finActualisation" : QtCore.SIGNAL( "finActualisation()" ),
"listeChaines" : QtCore.SIGNAL( "listeChaines(PyQt_PyObject)" ),
"listeEmissions" : QtCore.SIGNAL( "listeEmissions(PyQt_PyObject)" ),
"listeFichiers" : QtCore.SIGNAL( "listeFichiers(PyQt_PyObject)" ),
"nouvelleImage" : QtCore.SIGNAL( "nouvelleImage(PyQt_PyObject)" ),
"debutTelechargement" : QtCore.SIGNAL( "debutTelechargement(int)" ),
"pourcentageFichier" : QtCore.SIGNAL( "pourcentageFichier(int)" ),
"finTelechargement" : QtCore.SIGNAL( "finTelechargement(int)" ),
"finDesTelechargements" : QtCore.SIGNAL( "finDesTelechargements()" ),
}
## Methode qui envoie le signal
# @param nomSignal Le nom du signal a envoyer
# @param parametres Les parametres du signal
def signal( self, nomSignal, *parametres ):
if( self.listeSignaux.has_key( nomSignal ) ):
self.emit( self.listeSignaux[ nomSignal ], *parametres )
else:
logger.warn( "le signal %s n'existe pas" %( nomSignal ) )
| 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, 340 )
# La liste des widgets est vide
self.listeWidget = []
# Layout du dialog (il ne contiendra que la scroll area)
self.layoutPrincipal = QtGui.QVBoxLayout()
# Scroll Area (elle ne contiendra que le widget centreal )
self.scrollArea = QtGui.QScrollArea()
self.layoutPrincipal.addWidget( self.scrollArea )
# Widget central
self.widgetCentral = QtGui.QWidget()
# On cree un layout de grille (layout du widget central)
self.layoutGrille = QtGui.QGridLayout()
# 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 )
# Le widget central contient le layout de grille
self.widgetCentral.setLayout( self.layoutGrille )
# On adapte la taille du widget
self.widgetCentral.adjustSize()
# On ajoute le widget central a la scroll area
self.scrollArea.setWidget( self.widgetCentral )
# On met en place le layout principal qui contient la scroll area dans le dialog
self.dialogPreferences.setLayout( self.layoutPrincipal )
## 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)
"""
##########
# 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 #
###########
import logging
logger = logging.getLogger( __name__ )
from PyQt4 import QtGui, QtCore
from GUI.ConvertQString import *
##########
# 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)
def __init__( self, parent = None ):
# 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 )
# On accepte le drag'n drop
#~ self.setAcceptDrops( True )
#~ self.setDragDropMode( QtGui.QAbstractItemView.InternalMove )
#~ self.setDropIndicatorShown( True )
# Lorsqu'on fait un drag'n drop, on ne supprime rien
#~ self.setDragDropOverwriteMode( False )
## 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
## 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
def getLigne( self, numeroLigne ):
liste = []
for i in range( self.columnCount() ):
liste.append( self.takeItem( numeroLigne, i ) )
return liste
## 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
def copierLigne( self, numeroLigne ):
liste = []
for i in range( self.columnCount() ):
liste.append( self.item( numeroLigne, i ).clone() )
return liste
## 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 listeElements Liste des elements a mettre en place sur cette ligne
def setLigne( self, numeroLigne, listeElements ):
nbColonnes = self.columnCount()
# Les lignes ont le meme nombre d'elements ?
if( len( listeElements ) == nbColonnes ):
for i in range( nbColonnes ):
self.setItem( numeroLigne, i, listeElements[ i ] )
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( "pourquoi vouloir echanger une ligne avec elle meme ?!" )
## 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 )
self.adapterColonnes()
## Methode pour selectionner ou deselectionner toutes les checkbox d'une colonne
# @param numeroColonne Numero de la colonne qui contient les checkboxes
# @param deselectionner Indique s'il faut tout selectionner ou tout deselectionner
def cocherTout( self, numeroColonne, decocher = False ):
# On regarde s'il faut tout selectionner ou tout deselectionner
typeSelection = QtCore.Qt.Checked
if decocher:
typeSelection = QtCore.Qt.Unchecked
# Pour chaque ligne
for i in range( self.rowCount() ):
self.item( i, numeroColonne ).setCheckState( typeSelection )
## 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 |
#!/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
import threading
import time
##########
# Classe #
##########
## Fenetre d'attente du programme
class FenetreAttenteProgressDialog( QtGui.QProgressDialog ):
## Constructeur
# @param parent Fenetre parent
def __init__( self, parent ):
# Appel au constructeur de la classe mere
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() )
# On masque le bouton annuler
self.setCancelButton( None )
# Signaux
QtCore.QObject.connect( self,
QtCore.SIGNAL( "ouvrirFenetre(PyQt_PyObject)" ),
self.ouvrirSiNecessaire )
# Etat dans lequel on veut que soit la fenetre
# !!! : L'etat dans lequel on veut qu'elle soit n'est pas forcement l'etat dans lequel elle est
self.etatOuvert = False
# Mutex
self.lock = threading.Lock()
## Surcharge de la methode appelee lors de la fermeture du dialog
# Ne doit pas etre appele explicitement
# @param evenement Evenement qui a provoque la fermeture
def closeEvent( self, evenement ):
# Si la fenetre est masquee
if( self.isHidden() ):
# On accept la fermeture
evenement.accept()
else:
# On refuse la fermeture
evenement.ignore()
## Methode pour afficher la fenetre d'attente
# @param nomSite Nom du plugin (site) qui demande la fenetre d'attente
def ouvrirFenetreAttente( self, nomSite ):
self.lock.acquire()
# On veut que la fenetre soit ouverte
self.etatOuvert = True
self.lock.release()
# On attent un peu puis on ouvre la fenetre si necessaire
threading.Timer( 0.5, self.emit, ( QtCore.SIGNAL( "ouvrirFenetre(PyQt_PyObject)" ), nomSite ) ).start()
## Methode lancee par le timer apres X seconde qui ouvre la fenetre d'attente si c'est necessaire
# @param nomSite Nom du plugin (site) qui demande la fenetre d'attente
def ouvrirSiNecessaire( self, nomSite ):
self.lock.acquire()
# Si on veut toujours que la fenetre soit ouverte, on l'ouvre !
if( self.etatOuvert ):
self.setLabelText( "Patientez pendant l'actualisation des informations de %s" %( nomSite ) )
self.show()
self.lock.release()
## Methode pour fermer la fenetre d'attente
def fermerFenetreAttente( self ):
self.lock.acquire()
self.etatOuvert = False
# Si la fenetre est affiche, on la masque apres avoir un peu attendu
if not ( self.isHidden() ):
self.hide()
self.lock.release()
| 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.