Au hasard de mes parcours sur la toile — bon, en fait, je sais plus comment c’est venu, du coup, on va dire que c’est par hasard¹ —² je suis tombé sur cette page. Et j’ai découvert que le commun des mortels pouvait faire des choses incroyables (et pas forcément utiles, donc indispensables) comme mémoriser l’ordre des cartes d’un paquet de 54 cartes mélangées, retenir une liste de nombres pendant plusieurs semaines, résoudre le rubik’s cube en aveugle (je ne parle pas du temps de mémorisation ni de résolution ça c’est pour les mortels moins communs³), se rappeler de moults numéros de téléphone etc.

Il y a plusieurs techniques, qui ont l’air de se valoir, pour arriver à ce but (certaines étant plus adaptées à des tâches en particulier). Je ne vais pas les présenter, elles sont bien mieux détaillées que ce que je pourrais faire dans les différents liens qui viendront. Je vais décrire celle que j’utilise, qui est une adaptation de ce qui se fait.

* Personnes
** Item :drill:
   :PROPERTIES: 
   P-00
*** the answer
    Ken
** Item :drill:
   :PROPERTIES: 
   P-10
*** the answer
    Cabrel

(defun pao () "reviser son pao" (interactive) (find-file
  "~/.emacs.d/pao-drill.org") (org-drill) ) (global-set-key (kbd
  "<f11>") ’pao)

Je traduis là, grossièrement, la page http://frezcogames.com/Knights_Tour.php.

Pour plus d’information, voir également http://fredtantini.free.fr/blog/?article24/resoudre-le-probleme-du-cavalier.

Lire la suite de Résoudre le problème du cavalier les yeux fermés

Le problème du cavalier est le suivant : il faut déplacer un cavalier sur un échiquier de façon à ce qu’il passe par toutes les cases, une seule fois. On ajoute également souvent une contrainte : il doit pouvoir revenir à sa case de départ, un parcours dit « fermé » (et donc former un cycle hamiltonien).

De nombreux programmes permettent de résoudre ce problème, et c’est également un bon exercice pour ceux qui apprennent la programmation.

Évidemment, c’est un problème très intéressant mathématiquement, et algorithmiquement parlant. Mais ce qui m’intéresse ici, c’est plutôt de résoudre le problème de tête.

Lire la suite de Résoudre le problème du cavalier

Quand je veux récupérer plusieurs pages, je le fais souvent avec wget. L’utilisation des options --load-cookies, --save-cookies et --keep-session-cookies avec --post-data étant plus que pratique. Pour parser, ensuite, c’est souvent pénible, même si awk est là pour aider.

man wget donne :

# Log in to the server.  This can be done only once.
 wget --save-cookies cookies.txt \
      --post-data 'user=foo&password=bar' \
      http://server.com/auth.php

 # Now grab the page or pages we care about.
 wget --load-cookies cookies.txt \
      -p http://server.com/interesting/article.php

Pour parser, j’aime bien python ; je trouve ça plus lisible. Par contre, ce que j’utilisais jusqu’à présent pour me logguer sur une page était moins glop :

import urllib, urllib2, cookielib

username = 'foo'
password = 'bar'

cj = cookielib.CookieJar()
handle = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
login_data = urllib.urlencode({'username' : username, 'pwd' : password})
handle.open('http://www.example.com/login.php', login_data)
res = handle.open('http://www.example.com/my_account.php')
print res.read()

Mais ça, c’était avant. Depuis, j’ai découvert Requests. Pour faire un POST, c’est aussi simple que :

import requests

url= 'http://www.example.com/login.php'
login_data = {username = 'myuser', password = 'mypassword'}

req = requests.post(url, login_data)
page = req.content

Si on a besoin de gérer les cookies, on peut passer par une Session :

import requests

url= 'http://www.example.com'
login_data = {username = 'myuser', password = 'mypassword'}

s = requests.Session()
req = s.post(url + '/login.php', login_data)
req = s.get(url + '/my_account.php')

C’est quand même plus lisible, non ?

En fait, récemment, je voulais parcourir les images de la galerie d’un site. Mais cette galerie contenait 10 images seulement par page, pour 40 pages. J’ai donc fait un script pour mettre toutes les images sur une seule page.

Les images sont encapsulées par une balise a class="foo" et donc j’utilise BeautifulSoup pour toutes les lister (soup.findAll("a","foo")).

Comme j’ai « besoin » de consulter les images plusieurs fois, j’ai préféré enregistrer les images en local plutôt que de laisser un lien sur le site. Pour ça j’ai utilisé stream=True de la méthode .get (cf ce lien sur SO).

J’ai pas fait très propre puisque j’affiche la page sur stdout que je pipe avec tee pour mettre dans un fichier. Mais au moins, je vois si ça marche :þ

# -*- coding: utf-8 -*-
from BeautifulSoup import BeautifulSoup
from requests import session

login_data = { 'login': 'fredtantini', 
               'password': 'toto1234',
               'action': 1 }

urlToVisit = 'http://www.example.com'

#on ouvre une session
with session() as s:
    #on se connecte
    req = s.post(urlToVisit + '/login.php', data=login_data)
    print "<html><body>"
    #comme je sais qu’il y a 40 pages
    for nPage in xrange(1,41):
        #on récupère la page
        request = s.get(urlToVisit + '/some_page.php?p='+str(nPage))
        #que l’on passe à BS
        soup = BeautifulSoup(request.text)    
        print "<h1> Page - ",nPage,"</h1>"
        #Pour tous les liens
        for i in soup.findAll("a","foo"):
            #on récupère l’image
            r = s.get(urlToVisit + '/' + i.img['src'], stream=True)
            #on la télécharge par parties (cf lien SO plus haut)
            if r.status_code == 200:
                with open(i.img['alt'] + ".jpg", 'wb') as f:
                    for chunk in r.iter_content():
                        f.write(chunk)
            print str(i).replace('./images/', './')

print "</body></html>"

J’expliquais dans le billet sur le démarrage d’Emacs que

le code de eval-after-load sera exécuté seulement une fois […]

Les nomdumode-mode-hooks, eux, sont exécutés pour chaque buffer dans lequel le mode sera activé.

Pour illustrer mes propos, voici un code à mettre dans un nouveau buffer (C-x b auie) :

(setq auie 0)
(setq nrst 0)
(eval-after-load "python" ;puisque dans python.el
  '(progn
     (setq auie (1+ auie))
     ))


(add-hook 'python-mode-hook
          (lambda ()
            (setq nrst (1+ nrst))
            ))
(progn
  (python-mode)
  (message (concat "auie vaut :" (number-to-string auie) ", nrst : " (number-to-string nrst))))

Passez en mode elisp (M-x emacs-lisp-mode), puis évaluez le buffer (M-x eval-buffer). Un petit message devrait s’afficher. Allez à la fin du buffer (M->) et évaluez la dernière sexp (C-x C-e). Évaluez plusieurs fois ; constatez que auie n’augmente pas, nrst si.

Autrement dit, si l’on veut exécuter du code lorsque l’on passe dans le mode foo, et que l’on ne veut pas charger le fichier foo.el ni faire un (require 'foo) dans son fichier init.el, on a deux possibilités :

1. Utiliser eval-after-load pour exécuter du code une fois.
2. Utiliser add-hook pour exécuter du code plusieurs fois.

En fait, eval-after-load va exécuter le code à chaque fois que la bibliothèque est chargée. Mais généralement, on fait un (autoload 'foo-mode "foo" "docstring") ; au premier appel de foo-mode (avec un M-x ou avec un add-to-list 'auto-mode-alist), foo.el est chargé et le code du eval-after-load est exécuté. Aux prochains appels de foo-mode, foo.el est déjà chargé, le code n’est plus exécuté.

eval-after-load est donc approprié si l’on veut changer des valeurs par défaut :

(eval-after-load "ace-jump-mode"
  '(ace-jump-mode-enable-mark-sync)) ;par défaut, c’est à disable

(eval-after-load "foo-mode"
  '(my-init-foo-mode)) ; on charge des choses en plus

(eval-after-load "org"
  '(require 'ox-md nil t)) ;l’export markdown n’est pas chargé automatiquement

(eval-after-load 'foo-mode
  '(define-key foo-mode-map (kbd "C-à") 'my-useful-fonction)) ; un raccourci utilisé seulement pour ce mode

Le add-hook lui est utilisé à chaque fois que foo-mode est lancé (et non pas à chaque fois que foo.el est chargé). C’est ce choix que l’on fera si l’on veut activer un minor mode pour un major mode ou si on veut changer des valeurs de variables changées par le major mode.

; à chaque fois que l’on passe en elisp mode, on met les parenthèses en couleur
(add-hook 'emacs-lisp-mode 'rainbow-delimiters-mode)

;avant de sauver, on lance un nettoyage
(add-hook 'before-save-hook 'whitespace-cleanup)

;le mode foo redéfinit à chaque fois C-> et je ne veux pas
(add-hook 'foo-mode-hook '(lambda ()
  (define-key foo-mode-map "\C->" 'foobar))) 

;on met c-basic-offset à 4
(add-hook 'c-mode-common-hook
  '(lambda () 
     (setq c-basic-offset 4)))

;si on veut différentes valeurs selon que l’on soit en foo ou en bar
(add-hook foo-mode-hook
  '(lambda () 
    (setq spam 42)) nil t)

(add-hook bar-mode-hook
  '(lambda () 
    (setq spam 3.14)) nil t)

En espérant avoir été clair.

Utilisant la disposition de clavier bépo, et soucieux d’écrire le plus correctement possible, j’ai pris l’habitude de mettre des espaces insécables lorsque c’est nécessaire (même si, je l’avoue, je n’utilise pas les espaces fines… désolé). Depuis plusieurs jours, j’utilise également les apostrophes courbes (!wfr) et plus celles qui se trouve sur la touche 4 des claviers azerty, des droites : l’apostrophe courbe vs l'apostrophe droite.

Lire la suite de Un peu de typographie et marquer les raccourcis clavier dans org-mode

Il n’y a pas si longtemps, j’ai ouvert une gallerie pour la naissance de M. Je voulais quelque chose de vraiment simple, sans base de données et j’étais parti sur single file php gallery. Mais « les gens » m’ont dit que c’était trop lent. Du coup, j’ai cherché autre chose. Puis je me suis souvenu de Minigal Nano. Et tout allait pour le mieux dans le meilleur des mondes jusqu’à ce que quelqu’un me signale que le lien que je lui donne ne fonctionne pas, alors que je venais de tester… Après quelques veines tentatives de renommages des fichiers images, je me rends à l'évidence, c’est la faute à free… (Manquerait plus que ce soit de ma faute !)

Quelques recherches sur [<a href='function.opendir'>function.opendir</a>]: failed to open dir me font tomber sur ± le même problème qu’ont les gens qui veulent installer un dokuwiki sur un site .free.fr (entre autres). Du coup, je regarde comment le script liberator corrige le problème, et je vois qu’il y a un souci avec la fonction opendir (étonnant non ?)…

Me voilà donc à insérer la fonction suivante dans le fichier index.php :

function myopendir($x, $y=null) {
         if(!is_dir($x)) return false;
         return is_null($y) ? @opendir($x) : @opendir($x,$y);
}

et remplacer tous les @opendir / opendir par myopendir.

Et voilà une Minigal Nano qui roule.

La problèmatique du jour est la suivante : j'utilise actuellement selenium pour les besoins du boulot. Je vous passe les détails, mais j'ai moults fichiers html qui me permettent de tester le contenu d'un site. Sauf que ce site évolue parfois, et du coup, il me faut modifier relativement fréquemment ces fichiers. Heureusement qu'il y a findus emacs.

Lire la suite de Modifier des fichiers en masse avec Emacs

Lire la suite de Le nettoyage de mon .emacs