[Python] Faire une omelette!

[ark]

Hello,

Alors, comment faire une omelette en python ? Vous ne savez pas ? Ben c'est simple, utilisez des Egg ! (Oui, j'étais inspiré pour le jeu de mot =))
Je vais vous présenter vite fait le concept, parce que j'ai découvert ça hier, et j'aime bien l'idée =)

Un Egg en python, en fait c'est a peu près l'équivalent d'une archive .jar en java. Et plus concrètement, il s'agit d'une archive ZIP.

Pour l'exemple, voici un peu ce que l'on va packer :

Code :

$> tree
.
├── bar
│   ├── __init__.py
│   └── module.py
├── foo
│   └── __init__.py
└─── __main__.py

On peut voir ici que mon Egg contiendra deux packages : foo et bar qui eux contiennent du code python. On a aussi le __main__.py qui lui sera appelé au lancement de notre egg.

le code de ces fichiers:

./__main__.py

Code PYTHON :


#!/usr/bin/env python

import bar
import bar.module
from foo import Bar

if __name__ == "__main__" :

    a = Bar()
    b = bar.Foo()
    string = bar.module.DeadBeef().cipher("toto", 1)
    print("{}".format(string))
 

./bar/__init__.py

Code PYTHON :


class Foo :

    def __init__(self) :
        print("I'm foo")
 

Deux petites remarques ici :
- Oui, ma classe Foo est bien dans le repertoire bar ; pourquoi? Parce que j'avais envie =)
- J'utilise du python 3.4 (c'est tout beau tout neuf :D) Et du coup, pas besoin de preciser qu'une classe hérite de object quand on la déclare! C'est cool nan? Moi je trouve ça plus propre.

./bar/module.py

Code PYTHON :


class DeadBeef :

    def __init__(self) :
        pass

    def cipher(self, a : str, key : int) -> str :
        key = key & 0xff
        return "".join([chr(ord(x) ^ key) for x in a])
 

La fonction cipher, je vous laisse deviner ce qu'elle fait, c'est pas ce qui nous intéresse ici.

./foo/__init__.py

Code PYTHON :


class Bar :

    def __init__(self) :
        self.bar()

    def bar(self) :
        print("Hello World")
 

Voilà donc mes fichiers d'exemple. A ce stade, on peut lancer notre programme python tout simplement, soi en faisant:

Code BASH :


chmod +x ./__main__.py
./__main__.py
 

soit :

Code BASH :


python __main__.py
 

Je vous laisse tester si ça vous amuse, mais globalement, jusque là, rien de nouveau. Python va dans ce cas générer des dossiers __pycache__ dans les deux sous répertoires. Vous pouvez les supprimer avant de passer à la suite.

Maintenant, passons à l'omelette! =)
Pour faire notre Egg, rien de bien compliqué, on va tout simplement faire un (dans le repertoire courant) :

Code BASH :


zip -r egg_name ./
 

Avec ça, on obtiens donc un egg_name.zip ; que vous pouvez (ou non) renommer en egg_name.egg.

Dans tous les cas, vous pouvez déjà lancer cet Edd en faisant tout simplement :

Code BASH :


python egg_name.egg
 

Voilà =) Je trouve ce concept sympa, je sais pas de quand ça date, mais je connaissais pas, et franchement c'est carrément plus pratique pour envoyer un programme python à quelqu'un. De plus, il est possible de mettre des fichiers de LICENSE, README, CHANGELOG, etc dans l'Egg afin de faire un truc bien :p On peut apparement également y mettre un fichier setup.py qui permettrait d'installer l'egg directement :)
Bref, je suis fan! :p

[gruik]

nice je connaissais pas, mais c'est effectivement assez pratique pour peu qu'on ait un projet suffisamment volumineux/à plusieurs fichiers & modules, et c'est simple à mettre en œuvre

de ce que je lis les eggs permettent aussi notamment de spécifier via des metadatas les dépendances du package, y compris de
fournir des urls en vue de satisfaire les dépendances éventuelles, la hiérarchisation et la catégorisation des différents fichiers (quel module prend le pas sur les autres, quel point d'entrée, quelles sont les ressources, quels sont les scripts etc.) pour les setuptools, easy-install etc. et y compris le chiffrement via AES manifestement

plus d'infos sur le format