Contenu | Rechercher | Menus

Annonce

Si vous avez des soucis pour rester connecté, déconnectez-vous puis reconnectez-vous depuis ce lien en cochant la case
Me connecter automatiquement lors de mes prochaines visites.

À propos de l'équipe du forum.

Pages : 1

#1 Le 12/08/2012, à 10:51

sergeG75018

Vous en pensez quoi?(screenshot automatique)

Bonjour.
Étant au chômage (je ne travail pas dans l'informatique), j'en profite pour me perfectionner en script.
J'ai eu besoin de prendre des captures d'écran d'une manière récurrente toutes les x secondes.
J'ai essayer avec shutter et gnome-screenshooter mais aucun n'avait cette fonction.
J'ai donc fait ce petit script, qui pour moi aux vues de mais connaissances est énorme :-)
Il ce décompose en 3 fichiers.
1: Le script qui lance la procedure. >>Attention il y-a une boucle infinie.<<
2: un script qui tu la boucle infinie et arrête le processus.
3: Étant sous unity, un indicator qui lance le script qui tu le processus.
Je poste car je pense que cela peut être amélioré
Le script principal.

#récupère le PID du script et l'envoit dans un fichier texte pour pouvoir être tué par l'indicator.
echo $$ > pid_du_script

#fenêtre zenity pour donner le délais entre chaque captures.
secondes=$(zenity --entry \
--width 200 \
--height 50 \
--title="Délais" \
--text="Combien de secondes? ") &&

#fenêtre zenity qui permet de choisir le dossier de sauvegarde des captures et lance ou non le processus.
dossiersortie=$(zenity --file-selection \
--title="Choix du dossier" \
--text="Choisissez un dossier." \
--directory)
case $? in
  0)    #lance l'indicator
	./osc.indicator &
	#lance xwininfo qui permet en cliquant sur la fenêtre à capturer 
	#de renvoyer son PID sous la forme 0x000000 necessaire à import.
	xwininfo | grep -n id: | cut -d" " -f4 > pid_du_logiciel && #là ça peut être amélioré en créant une variable
	id=`cat pid_du_logiciel`                                    #mais faut que je repose un peu mes neurones
	#là on lance import dans un boucle infinie
	while :
	do
	import -window "$id" -pause $secondes "$dossiersortie/capture-"$(date +"%d.%m.%y-%H.%M.%S")".png"
	done;;
  1)
	exit 2;;
  -1)
	exit 1;;
esac
	;;

Il peut-être amélioré en y incluant la prise de fullcreens type jeux vidéo mais deux fenêtres zenity ça suffit ( c'est faisable et facile), il faudrait passer par glade et là j'y connais rien.

Le cript qui kill la boucle infinie.

#!/bin/bash
#récupère le PID du script dans le fichier texte.
pid_du_script=`cat pid_du_script`
#tu le script.
kill $pid_du_script &
#supprime les fichiers temporaires
rm pid_du_script pid_du_logiciel

Le script de l'indicator pour unity qui kill le script, il est fait de bric et broc parce que python et moi!
mais je vais m'y mettre, promis.

#!/usr/bin/env python
import gtk
import appindicator
import os
class AppIndicator:
    def __init__(self):
        self.ind = appindicator.Indicator("autoscreenshoter",
            "applets-screenshooter", appindicator.CATEGORY_APPLICATION_STATUS)
        self.ind.set_status (appindicator.STATUS_ACTIVE)
        self.menu = gtk.Menu()
        item = gtk.MenuItem("Quitter")
        item.connect("activate", self.quit)
        self.menu.append(item)
        self.menu.show_all()
        self.ind.set_menu(self.menu)

    def quit(self, *args):
        os.system("./killscript")
        gtk.main_quit()

AppIndicator()
gtk.main()

Voilà dites moi si j'ai fais des erreurs cela me permettra d'évoluer.
merci et bonne journée.

Ironie, sarcasme ou cynisme? Je ne sais plus

Hors ligne

#2 Le 12/08/2012, à 22:25

papy88140

Re : Vous en pensez quoi?(screenshot automatique)

Le plus simple serait de tout intégrer dans le script python neutral

D'autant plus que la librairie glib intègre des fonctions de timer !

J'ai eu la même chose à faire pour un programme qui change le papier peint du bureau à intervalle régulier.

Le code est pas non plus super propre mais il peut donner des idées [ pas de meurtre j'espère smile ]

Voila :


#!/usr/bin/python
# -*- coding: utf-8 -*-

# codé par Papy - Fabrice PIERROT

# ce code est placé sous licence GPL 2
# http://www.linux-france.org/article/these/gpl.html

#
# version 13-04-2012
#

import pygtk
pygtk.require('2.0')
import gtk,os,string,subprocess
import urllib2,random,time,datetime
import string,re,hashlib,glib
import appindicator
from gtkforms import *

# http://images.alphacoders.com/158/

class wallbaseConfig:
	
	def __init__(self):
		self.tags = ""
		self.anime = ""
		self.model =""
		self.purity = ""
		
class papyWpTray:

	def startCronWp(self):
		print "Start"
		self.cron=True
		self.changeWp()
		self.callback=glib.timeout_add_seconds(15,self.changeWp)

	def stopCronWp(self):
		print "stop"
		self.cron=False
		glib.source_remove(self.callback)
		self.callback=0

	def cronWp(self, widget):
		if widget.active:
			self.startCronWp()
		else:
			self.stopCronWp()

	def saveWp(self, widget):

		md5=open("%s/.papyWp.md5" % (self.homeDir)).readline()

		pictureOrg =open("%s/.papyWp.jpg" % (self.homeDir)).read()
		pictureCopy = open("%s/papyWp_%s.jpg" % (self.pictureDir,md5),"w").write(pictureOrg)

		# notification de la sauvegarde

	
	def nextWp(self, widget):

		if self.callback > 0 :
			glib.source_remove(self.callback)

		self.changeWp()

		if self.callback > 0 :
			self.callback=glib.timeout_add_seconds(15,self.changeWp)

	def quit(self, widget):
		gtk.main_quit()

	def popup_menu(self, widget, button, time, data = None):

		if button == 3:
			if data:
				data.show_all()
				data.popup(None, None, gtk.status_icon_position_menu,
					   3, time, self.statusIcon)

	# code issu du site http://stackoverflow.com/questions/3431825/python-generating-a-md5-checksum-of-a-file

	def hashfile(self, afile, hasher, blocksize=65536):
		buf = afile.read(blocksize)
		while len(buf) > 0:
			hasher.update(buf)
			buf = afile.read(blocksize)
		return hasher.hexdigest()

	# fin du code
				

	def changeWp(self):

		print "change WP from %s for %s with callback %s" % (self.repository,self.shell,self.callback)

		my_picture=self.loader[self.repository]()

		filenamePicture = "%s/.papyWp.jpg" % (self.homeDir)
		filenameMd5 = "%s/.papyWp.md5" % (self.homeDir)


		try:
			filePicture = open(filenamePicture, "wb")
			filePicture.write(my_picture)
			filePicture.close()

			md5=self.hashfile(file(filenamePicture,'r'),hashlib.md5())

			fileMd5 = open(filenameMd5, "wb")
			fileMd5.write(md5)
			fileMd5.close()

		except:
			pass

		return(self.cron)
		
	# --- code issu du site : http://stackoverflow.com/questions/553303/generate-a-random-date-between-two-other-dates
	def strTimeProp(self, start, end, format, prop):

		stime = time.mktime(time.strptime(start, format))
		etime = time.mktime(time.strptime(end, format))

		ptime = stime + prop * (etime - stime)

		return time.strftime(format, time.localtime(ptime))

	def randomDate(self, start, end, prop):
		return self.strTimeProp(start, end, '%Y/%m/%d', prop)

	# --- fin du code

	def flickr(self):

		opener = urllib2.build_opener()

		reLien = re.compile("<a href=[^>]*>")
		rePhoto = re.compile("""\"/photos/[^\"^/]*/[^\"^/]*/\"""")
		reUrl1 = re.compile("""url: \'[^\']*_b.jpg\'""")
		reUrl2 = re.compile("""url: \'[^\']*_z.jpg\'""")
		reUrl3 = re.compile("""url: \'[^\']*.jpg\'""")

		try:
			page = opener.open("http://www.flickr.com/explore/interesting/%s/page%02i/" % (self.randomDate("2010/01/01", "2011/07/27", random.random()),random.randint(1,6)))
			html = page.read()
			page.close()

			photos=rePhoto.findall(html)

			index=random.randint(1, len(photos)-1)

			page=opener.open("http://www.flickr.com%s" % (photos[index][1:len(photos[index])-1]))
			html=page.read()

		except:
			print "retry"
			return self.flickr()


		adrPhoto=reUrl1.findall(html)

		if len(adrPhoto) == 0 :
			adrPhoto=reUrl2.findall(html)
			if len(adrPhoto) == 0 :
				adrPhoto=reUrl3.findall(html)

		try:
			adrPhoto=adrPhoto[len(adrPhoto)-1][6:-1]
			page = opener.open(adrPhoto)
			my_picture = page.read()
			page.close()
		except:
			print "retry"
			return self.flickr()

		return my_picture

	def wallbase(self):

		opener = urllib2.build_opener()
		motif=re.compile("""<a href="http://wallbase.cc/wallpaper/[^\"]*""")
		motif2=re.compile("""img src=\"http://[^\"]*.jpg""")

		while len(self.wallbaseListe) == 0 :
			print "lecture liste"
			try:
				page = opener.open("http://wallbase.cc/search","query=%s&board=2&nsfw=%s%s%s&res=0x0&res_opt=eqeq&aspect=%s&orderby=random&orderby_opt=desc&thpp=60&section=wallpapers" % (self.wallbaseConfig.tags,self.wallbaseConfig.anime,self.wallbaseConfig.model,self.wallbaseConfig.purity,self.ratio))
				html=page.read()
				page.close()
				self.wallbaseListe = motif.findall(html)
			except:
				print "retry"

		print len(self.wallbaseListe)
		url=self.wallbaseListe[random.randint(0,len(self.wallbaseListe)-1)]

		pic_urls = []
		while len(pic_urls) == 0 :
			try :
				page = opener.open(url[9:])
				html=page.read()
				page.close()
				pic_urls=motif2.findall(html)
				pic_url=pic_urls[0][9:]
				my_picture = opener.open(pic_url).read()
				self.wallbaseListe.remove(url)

				return my_picture
			
			except :
				print "retry"
				self.wallbaseListe.remove(url)
				return self.wallbase()


	def _500px(self):
		opener = urllib2.build_opener()
		motif=re.compile("""http://pcdn.500px.net/[^\"]*4.jpg\"""")

		number = random.randint(1,6000000)

		try:
			page = opener.open("http://500px.com/photo/%s" % (number))
			html=page.read()
			page.close()
			my_picture = opener.open(motif.findall(html)[0][:-1]).read()
			return my_picture
		except:
			print "retry"
			return self._500px()

	def setFlickr(self,widget):
		self.label_500px.set_text("500px")
		self.label_flickr.set_text("--> flickr")
		self.label_wallbase.set_text("Wallbase")
		self.repository="flickr"

	def setWallbase(self,widget):
		self.label_500px.set_text("500px")
		self.label_flickr.set_text("flickr")
		self.label_wallbase.set_text("--> Wallbase")
		self.repository="wallbase"

	def set500px(self,widget):
		self.label_500px.set_text("--> 500px")
		self.label_flickr.set_text("flickr")
		self.label_wallbase.set_text("Wallbase")
		self.repository="500px"
		
	def configuration(self,widget):
		create_gtk_dialog_from_object(self.wallbaseConfig).run()
		self.wallbaseListe=[]

	def __init__(self): 

		# Définition des variables

		self.homeDir = os.path.expanduser("~")

		dirs=open("%s/.config/user-dirs.dirs" % (self.homeDir)).readlines()

		for ligne in dirs:
			if ligne[4:12] == "PICTURES" :
			    self.pictureDir = string.replace(ligne[18:-2],"$HOME",os.path.expanduser("~"))

		self.cron=False
		self.callback=0

		self.loader={}

		self.loader["flickr"]=self.flickr
		self.loader["wallbase"]=self.wallbase
		self.loader["500px"]=self._500px

		self.repository="flickr"
		
		self.wallbaseConfig = wallbaseConfig()
		self.wallbaseListe = []

		self.wallbaseConfig.tags = ""
		self.wallbaseConfig.anime = "0"
		self.wallbaseConfig.model = "0"
		self.wallbaseConfig.purity = "0"
		
		# détection de la résolution de l'écran

		p1 = subprocess.Popen(args=["xrandr"],stdout=subprocess.PIPE)
		p2 = subprocess.Popen(args=["grep",'*'],stdin=p1.stdout,stdout=subprocess.PIPE)
		p1.stdout.close()
		self.resolution = p2.communicate()[0].split()[0]
		p2.stdout.close()

		self.resolution_x,self.resolution_y = self.resolution.split("x")

		self.ratio=str(float(self.resolution_x)/int(self.resolution_y))[0:4]

		print self.ratio

		out,err = subprocess.Popen(args=["ps","-C","unity-panel-service"],stdout=subprocess.PIPE).communicate()

		# détection du shell graphique

		if string.find(out,"unity") >0 :
			self.shell="Unity"
		else :
			self.shell="Unity" # gnome
		
		print self.shell

		# initialisation du format du fond d'écran

		filenamePicture = "%s/.papyWp.jpg" % (self.homeDir)

		if self.shell == "Unity" :
			subprocess.Popen(args=["gsettings","set","org.gnome.desktop.background","picture-uri","file://%s"%(filenamePicture)])
			subprocess.Popen(args=["gsettings","set","org.gnome.desktop.background","picture-options","scaled"])
		else :
			subprocess.Popen(args=["gconftool-2","--type=string","--set","/desktop/gnome/background/picture_filename","%s"%(filenamePicture)])
			subprocess.Popen(args=["gconftool-2","--type=string","--set","/desktop/gnome/background/picture_options","scaled"])
			subprocess.Popen(args=["gconftool-2","--type=string","--set","/desktop/gnome/background/primary_color","#000000000000"])


		# création de l'application systray


		if self.shell == "Gnome" :

			self.app = gtk.StatusIcon()

			try :
				open("%s/wpIcon.svg"%(self.homeDir))
				self.app.set_from_file("%s/wpIcon.svg"%(self.homeDir))
			except :
				self.app.set_from_stock(gtk.STOCK_ABOUT)

		else :
			self.app = appindicator.Indicator("PapyWallpaperTray","applications-system", appindicator.CATEGORY_OTHER)
			self.app.set_status(appindicator.STATUS_ACTIVE)
			try :
				open("%s/wpIcon.svg"%(self.homeDir))
				self.app.set_icon("%s/wpIcon.svg"%(self.homeDir))
			except :
				pass

		# définition du menu

		self.menu = gtk.Menu()

		self.menuItem_roll = gtk.CheckMenuItem("Tournant")
		self.menuItem_roll.connect('activate', self.cronWp)
		self.menu.append(self.menuItem_roll)

		self.menuItem_save = gtk.ImageMenuItem(gtk.STOCK_SAVE)
		self.menuItem_save.connect('activate', self.saveWp)
		self.menu.append(self.menuItem_save)
		
		self.menuItem_next = gtk.ImageMenuItem(gtk.STOCK_GO_FORWARD)
		self.menuItem_next.connect('activate', self.nextWp)
		self.menu.append(self.menuItem_next)

		self.menu.append(gtk.SeparatorMenuItem())

		self.menuItem_flickr = gtk.MenuItem()
		self.label_flickr = gtk.Label("--> Flickr")
		self.menuItem_flickr.add(self.label_flickr)
		self.menuItem_flickr.connect('activate', self.setFlickr)
		self.menu.append(self.menuItem_flickr)

		self.menuItem_wallbase = gtk.MenuItem()
		self.label_wallbase = gtk.Label("Wallbase")
		self.menuItem_wallbase.add(self.label_wallbase)
		self.menuItem_wallbase.connect('activate', self.setWallbase)
		self.menu.append(self.menuItem_wallbase)

		self.menuItem_500px = gtk.MenuItem()
		self.label_500px = gtk.Label("500px")
		self.menuItem_500px.add(self.label_500px)
		self.menuItem_500px.connect('activate', self.set500px)
		self.menu.append(self.menuItem_500px)

		self.menu.append(gtk.SeparatorMenuItem())

		self.menuItem_config = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
		self.menuItem_config.connect('activate', self.configuration)
		self.menu.append(self.menuItem_config)

		self.menu.append(gtk.SeparatorMenuItem())

		self.menuItem_quit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
		self.menuItem_quit.connect('activate', self.quit)
		self.menu.append(self.menuItem_quit)

		self.menu.show_all()


		# intégration du menu à l'appli

		if self.shell == "Gnome" :

			self.app.set_visible(True)
			self.app.set_tooltip("PapyWallpaperTray")

			self.app.connect('popup-menu', self.popup_menu, self.menu)
			self.app.set_visible(1)

		else :

			self.menu.show()
			self.app.set_menu(self.menu)


if __name__ == "__main__":

	papyWpTray = papyWpTray()
	gtk.main()

Linux à Contrexéville ?
http://leclug.free.fr/forum/

Hors ligne

#3 Le 13/08/2012, à 11:16

sergeG75018

Re : Vous en pensez quoi?(screenshot automatique)

bonjour.
Pour l'instant je suis sur bash, pour python on verra plus tard.
Je me rends compte que je me suis pris la tête pour pas grand chose car un simple 

set -e

résolvait mon problème de boucle infini et de fait rendait inutile l'utilisation d'un indicator et d'un script pour arrêter la boucle.
merci.

#!/bin/bash
#necessite zenity, xwininfo et import (outil d'imagemagick) qui sont je crois de base dans ubuntu.

#Arrêter le script en cas d'erreur. À la fermeture de la fenêtre capturée import va générer une
#erreur et donc le script va s'arrêter
set -e
#fenêtre zenity pour donner le délais entre chaque captures.
secondes=$(zenity --entry \
--width 200 \
--height 50 \
--title="Délais" \
--text="Combien de secondes? ") &&

#fenêtre zenity qui permet de choisir le dossier de sauvegarde des captures et lance ou non le processus.
dossiersortie=$(zenity --file-selection \
--width 500 \
--height 450 \
--title="Choix du dossier" \
--text="Choisissez un dossier." \
--directory)
case $? in
  0)    
	#lance xwininfo qui permet en cliquant sur la fenêtre à capturer 
	#de renvoyer son PID sous la forme 0x000000 necessaire à import.
	id=`xwininfo | grep -n id: | cut -d" " -f4`
	#là on lance import dans un boucle infinie
	while :
	do
	import -window "$id" -pause $secondes "$dossiersortie/capture-"$(date +"%d.%m.%y-%H.%M.%S")".png"
	done;;
  1)
	exit 2;;
  -1)
	exit 1;;
esac
	;;

edit: j'ai juste rajouter la variable pour xwininfo

id=`xwininfo | grep -n id: | cut -d" " -f4`

Dernière modification par sergeG75018 (Le 13/08/2012, à 11:30)

Ironie, sarcasme ou cynisme? Je ne sais plus

Hors ligne

Pages : 1