.mobo

Moteurs d'inférence et passerelle LiteLLM

2025-11-24T00:00:00+01:00

Après avoir exploré la création d'une première IA locale avec Ollama et OpenWebUI, nous passons à l'étape suivante: déployer des modèles sur des moteurs d'inférence de production et les servir avec LiteLLM.

Qu'est-ce qu'un moteur d'inférence ?

Un moteur d'inférence charge un modèle de LLM en mémoire et exécute les requêtes entrantes. Il peut gérer différents types de modèles, appliquer des paramètres d'exécution et servir les réponses via une API. Dans l'atelier précédent, nous avons utilisé Ollama, simple et efficace pour un usage local.

LiteLLM

LiteLLM est une passerelle entre les moteurs d'inférence (Ollama, vLLM, etc.) et des clients comme OpenWebUI. Il offre :

Une API compatible OpenAI
L'agrégation de modèles
Le load-balancing et fallback
La gestion du budget et des utilisateurs
Des contrôles de santé (health checks)

Installation et configuration

On commence par créer un projet, activer un environnement virtuel Python et installer litellm :

mkdir monprojet && cd monprojet
python -m venv .env && source .env/bin/activate
pip install litellm[proxy]

Ensuite, un fichier config.yaml définit les modèles et paramètres :

general_settings:
    master_key: sk-secret

model_list:
- model_name: qwen3
    model_info:
        max_tokens: 32768
        max_input_tokens: 16384
        max_output_tokens: 16384
    litellm_params:
        model: ollama/qwen3:0.6b
        api_base: http://localhost:11434
        temperature: 0.7
        max_tokens: 4096
        top_p: 0.9
        frequency_penalty: 1
        tpm: 300000
        rpm: 300

litellm_settings:
    num_retries: 3
    request_timeout: 3600
    allowed_fails: 5
    cooldown_time: 30

Ici, on sert le modèle "qwen3" via LiteLLM qu'on a configuré lors de l'article précédent. On peut ajuster les paramètres de génération comme la température, top_p, ou les pénalités de fréquence.

Exécution et requêtes

On démarre litellm avec cette configuration :

litellm --config config.yaml

L'API est disponible sur http://localhost:4000/. On peut vérifier l'état du serveur avec :

curl -H "Authorization: Bearer sk-secret" http://localhost:4000/health

Et pour interroger le modèle, tu peux faire un appel POST comme suit :

curl -X POST http://localhost:4000/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer sk-secret" \
-d '{
    "model": "qwen3",
    "messages": [{"role": "user", "content": "Hello!"}]
}'

Support multi-modèles et fallback

LiteLLM permet d’ajouter un second modèle (ex. qwen2.5) et de configurer le fallback.

model_list:
- model_name: qwen2.5
    model_info:
        max_tokens: 32768
        max_input_tokens: 16384
        max_output_tokens: 16384
    litellm_params:
        model: ollama/qwen2.5:0.5b
        api_base: http://localhost:11434

litellm_settings:
    fallbacks:
        [
            {"qwen3": ["qwen2.5"]}
        ]

Pour faire du load-balancing, il suffit de donner le même model_name à plusieurs moteurs.

Les requêtes sont alors réparties selon la configuration des poids et priorités avec les paramètres weight, rpm (requests per minute) et tpm (tokens per minute).

Utilisation avec Python

L'api de litellm étant openai compatible, tu peux utiliser le client OpenAI pour faire des requêtes :

pip install openai

Exemple d'appel depuis Python :

import openai

client = openai.OpenAI(api_key="sk-secret", base_url="http://localhost:4000")
response = client.chat.completions.create(
    model="qwen",
    messages=[{"role": "user", "content": "Écris un court poème"}]
)
print(response.choices[0].message.content)

vLLM : moteur pour de la production

Pour des usages plus lourds, vLLM offre :

Optimisation mémoire GPU avec PagedAttention
Exécution simultanée de plusieurs requêtes
Tensor Parallelism pour multi-GPU
API OpenAI compatible
Support LoRA et quantification
Intégration Kubernetes avancée
Métriques exposées pour Prometheus

Tu peux l'installer et démarrer un modèle Qwen 3 FP8 avec :

pip install vllm
vllm serve Qwen/Qwen3-0.6B-FP8

Et tu peux faire du paramétrage avancé sur deux GPUs avec :

vllm serve --model Qwen/Qwen3-0.6B-FP8 \
--max-model-len 40960 \
--gpu-memory-utilization 0.8 \
--swap-space 8 \
--dtype bfloat16 \
--kv-cache-dtype fp8 \
--tensor-parallel-size 2 \
--enable-auto-tool-choice --tool-call-parser hermes \
--enable-reasoning --reasoning-parser deepseek_r1 \
--disable-log-stats --disable-log-requests

Métriques Prometheus et tableau de bord Grafana

Les métriques sont exposées sur http://localhost:8000/metrics, permettant le suivi de l’utilisation GPU, des requêtes et des performances.

Autres moteurs

SGLang : concurrent direct de vLLM (http://sglang.ai/)
MAX : alternative sans CUDA (https://www.modular.com/max)
Speaches : spécialisé en TTS et STT (https://speaches.ai/)
Infinity : embeddings et reranking (https://github.com/michaelfeil/infinity)

Conclusion

Avec LiteLLM et vLLM, tu peux passer d’un prototype local à un déploiement de modèles LLM en production, avec gestion des utilisateurs, load-balancing, métriques et intégration multi-GPU. Ces outils constituent la passerelle idéale entre la facilité d’Ollama et la robustesse des moteurs professionnels.

Ma première IA locale avec Ollama et OpenWebUI

2025-11-24T00:00:00+01:00

Après avoir parlé d'architecture LLM et d'agents, on va revenir à la base de la base : installer une IA sur son poste et la faire parler.

L'objectif ? Démystifier ce qu'est un moteur d'inférence, manipuler un premier modèle, jouer avec les paramètres, et monter une petite interface web pour chatter avec ton LLM. Le tout en local, sans cloud, sans clé API, juste avec ton Linux et deux outils : Ollama et OpenWebUI.

C'est quoi un LLM, déjà ?

Avant de lancer des commandes dans le terminal, petit rappel rapide.

Un LLM (Large Language Model), c'est un gros réseau de neurones entraîné à un niveau indécent sur des montagnes de texte. Son job est simple : prédire le mot suivant.

Mais derrière ce côté simpliste, tu as tout un pipeline :

des tokens (morceaux de mots),
une vectorisation (représentation mathématique des idées),
un mécanisme Transformer qui pige le contexte d'une phrase,
et un modèle qui sort une probabilité pour chaque mot possible.

Tu lui donnes une phrase, il complète. Tu lui poses une question, il infère. Tu lui fournis un contexte, il adapte sa réponse.

Les modèles modernes comme Qwen, Llama 3 ou Mistral tournent aujourd'hui très bien en local, même sur de petites machines. Et c'est exactement ce qu'on va exploiter.

Ollama : ton premier moteur d'inférence

Ollama, c'est un petit bijou : un moteur d'inférence ultra simple à installer, compatible Linux/macOS/Windows, et surtout très efficace pour gérer et exécuter des modèles LLM localement.

Tu l'installes en une commande:

curl -fsSL https://ollama.com/install.sh | sh

Tu vérifies:

ollama -v

Et tu lances le moteur:

ollama serve

Pour être sûr que c'est ok, tu peux vérifier le port via telnet:

telnet localhost 11434

Maintenant, le plus sympa : télécharger un modèle.

Par exemple un qwen3:0.6b, petit mais très rapide:

ollama pull qwen3:0.6b

L'avantage de ce modèle, c'est que tu peux le faire tourner sur un CPU. Pas besoin de carte graphique.

Tu listes alors tes modèles:

ollama list

Et tu discutes avec lui:

ollama run qwen3:0.6b

Jouer avec les paramètres : créativité et contrôle

Une des forces d'Ollama, c'est la possibilité de régler très simplement les paramètres:

température : créativité / chaos
top-k : combien de candidats on garde avant de choisir
top-p : probabilité cumulée à couvrir
repeat-penalty : éviter que le modèle te fasse un copier-coller de lui-même

Tu lances:

/show parameters

Puis tu modifies:

/set parameter temperature 0

Des paramètres plus bas donnent des réponses plus précises et conservatrices, tandis que des valeurs plus élevées rendent les réponses plus variées et créatives. Tout dépend de ton usage !

Créer ton propre modèle : le Modelfile

Ollama te permet d'ajouter un comportement système directement dans un fichier Modelfile:

FROM qwen3:0.6b

PARAMETER temperature 0.7
PARAMETER top_k 30
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1

SYSTEM """
Rôle : Tu es un chat qui découvre un objet mystérieux dans son jardin.
Langue : Tu parles un français soutenu.
Personnalité : Tu es farceur.
"""

Compilation:

ollama create chat -f ./Modelfile

Tu peux alors discuter avec ton modèle personnalisé de la même façon que précédemment:

ollama run chat

Utiliser Ollama avec Python

Créer l'environnement virtuel:

python -m venv .env
source .env/bin/activate
pip install ollama

Script main.py pour chatter avec le modèle chat:latest:

from ollama import Client

client = Client()

messages = [
  {
    'role': 'user',
    'content': "Qui es-tu et que fais-tu aujourd'hui?",
  },
]

for part in client.chat('chat:latest', messages=messages, stream=True):
  print(part['message']['content'], end='', flush=True)

Exécution du code:

python main.py

Tu remarqueras qu'on a utilisé ici le mode streaming pour afficher la réponse au fur et à mesure. Pratique pour les interfaces web !

OpenWebUI : une interface web pour ton LLM

OpenWebUI est une interface web open-source qui te permet de chatter avec tes modèles locaux (Ollama, LocalAI, etc.) via une interface moderne. C'est l'outil le plus suivi dans le monde des LLM locaux avec LibreChat.

Installation Python:

pip install open-webui
open-webui serve

Ou via Docker:

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway \
-v open-webui:/app/backend/data --name open-webui \
--restart always ghcr.io/open-webui/open-webui:main

Tu ouvres:

http://localhost:8080/

Tu y retrouveras :

chat multi-modèles
historique
RAG intégré
administration
API
paramètres avancés

Première expérience RAG

OpenWebUI permet de créer un petit RAG local : uploader un PDF, notes, markdown. On peut poser des questions comme :

Explique la page 12 du PDF
Fais-moi un résumé
Trouve tous les passages sur Kubernetes

Conclusion

Avec Ollama et OpenWebUI tu as :

un moteur d'inférence local,
une interface moderne,
la possibilité d'ajouter une personnalité (Modelfile),
une API Python,
un premier RAG,
bref : ta première IA personnelle.

Bonne exploration !

Développement d'agents IA

2025-09-05T00:00:00+02:00

Après avoir passé en revue l'architecture de base des LLMs avec les moteurs d'inférence et l'orchestration de base, on va faire une petite introduction aux agents IA avec un outil ultra léger qui nous vient d'OpenAI appelé OpenAI Agents SDK et une petite librairie sympa appelée Agno.

Qu'est ce qu'un agent IA ?

Déjà pour commencer, démystifions le terme agent. On l'entend à toutes les sauces et ça veut tout et rien dire au premier abord.

Donc déjà, un agent c'est quoi ?

Un agent, c'est juste une fonction qui va prendre ton prompt d'entrée, faire l'appel au LLM et te restituer la réponse.

La spécificité d'un agent réside dans ce qu'il peut utiliser autour de ça :

des instructions : pour indiquer le comportement de l'agent. Il s'agit du prompt système en réalité.
un historique : pour garder le contexte de la conversation en cours. On pourra le stocker dans une base de données ou en mémoire.
une mémoire : pour se souvenir des préférences de l'utilisateur, de ses habitudes, du style de réponse et autres.
des outils : pour appeler des fonctions personnalisées comme l'appel à des API externes, l'exécution de calculs ou autres.
des connaissances : pour enrichir le contexte de l'agent et lui permettre de mieux comprendre et répondre aux requêtes. En général, c'est couplé à une base de données vectorielle. C'est la technique qu'on appelle communément RAG.
du raisonnement : pour réfléchir en amont et décider de la stratégie à adopter sur les appels d'outils par exemple.

Un agent peut également déléguer des tâches à d'autres agents spécialisés, c'est ce qu'on appelle un workflow d'agents.

Agno

Il existe plusieurs bibliothèques d'agents, plus ou moins complexes et complètes. La première que j'ai découverte qui m'avait tapé dans l'œil était Agno qui est vraiment complet et qui permet de faire beaucoup de choses. C'est elle qui m'a permis de comprendre le concept d'agent.

Elle définit plusieurs niveaux d'agents, ce qui permet de se lancer progressivement en fonction des besoins. Tu l'installes déjà avec pip par exemple :

pip install agno

Niveau 1 : Agents avec des outils et des instructions

Ici, on a notre premier agent qui va utiliser le modèle Claude pour récupérer des données sous forme de tableau via une recherche web avec un outil permettant d'interroger DuckDuckGo.

from agno.agent import Agent
from agno.models.anthropic import Claude
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    model=Claude(id="claude-sonnet-4-20250514"),
    tools=[DuckDuckGoTools()],
    instructions="Use tables to display data. Don't include any other text.",
    markdown=True,
)
agent.print_response("What is the stock price of Apple?", stream=True)

Niveau 2 : Agents avec un historique et des connaissances

Cet agent stocke la conversation dans une base de données SQLite pour pouvoir par la suite la passer en contexte.

Il utilise également une base de données vectorielle LanceDB pour stocker des connaissances issues de fichiers Markdown.

Avant de répondre à la question, l'agent va automatiquement chercher les infos dans la base de connaissances pour enrichir le contexte.

from agno.agent import Agent
from agno.embedder.openai import OpenAIEmbedder
from agno.knowledge.url import UrlKnowledge
from agno.models.anthropic import Claude
from agno.storage.sqlite import SqliteStorage
from agno.vectordb.lancedb import LanceDb, SearchType

knowledge = UrlKnowledge(
    urls=["https://docs.agno.com/introduction.md"],
    vector_db=LanceDb(
        uri="tmp/lancedb",
        table_name="agno_docs",
        search_type=SearchType.hybrid,
        embedder=OpenAIEmbedder(id="text-embedding-3-small", dimensions=1536),
    ),
)

storage = SqliteStorage(table_name="agent_sessions", db_file="tmp/agent.db")

agent = Agent(
    name="Agno Assist",
    model=Claude(id="claude-sonnet-4-20250514"),
    instructions=[
        "Search your knowledge before answering the question.",
        "Only include the output in your response. No other text.",
    ],
    knowledge=knowledge,
    storage=storage,
    add_datetime_to_instructions=True,
    add_history_to_messages=True,
    num_history_runs=3,
    markdown=True,
)

if __name__ == "__main__":
    agent.knowledge.load(recreate=False)
    agent.print_response("What is Agno?", stream=True)

Niveau 3 : Agents avec une mémoire et du raisonnement

La mémoire est stockée dans une base SQLite et on laisse le modèle la gérer comme il l'entend.

Le raisonnement est ici géré par un outil appelé ReasoningTools et tu peux voir l'intégralité du raisonnement grâce à show_full_reasoning=True.

from agno.agent import Agent
from agno.memory.v2.db.sqlite import SqliteMemoryDb
from agno.memory.v2.memory import Memory
from agno.models.anthropic import Claude
from agno.tools.reasoning import ReasoningTools
from agno.tools.duckduckgo import DuckDuckGoTools

memory = Memory(
    model=Claude(id="claude-sonnet-4-20250514"),
    db=SqliteMemoryDb(table_name="user_memories", db_file="tmp/agent.db"),
    delete_memories=True,
    clear_memories=True,
)

agent = Agent(
    model=Claude(id="claude-sonnet-4-20250514"),
    tools=[
        ReasoningTools(add_instructions=True),
        DuckDuckGoTools(search=True, news=True),
    ],
    user_id="ava",
    instructions=[
        "Use tables to display data.",
        "Include sources in your response.",
        "Only include the report in your response. No other text.",
    ],
    memory=memory,
    enable_agentic_memory=True,
    markdown=True,
)

if __name__ == "__main__":
    agent.print_response(
        "My favorite stocks are NVIDIA and TSLA",
        stream=True,
        show_full_reasoning=True,
        stream_intermediate_steps=True,
    )
    agent.print_response(
        "Can you compare my favorite stocks?",
        stream=True,
        show_full_reasoning=True,
        stream_intermediate_steps=True,
    )

OpenAI Agents SDK

Une autre bibliothèque minimaliste sortie récemment est OpenAI Agents SDK.

Elle est assez proche du fonctionnement d'Agno mais plus légère et plus simple à prendre en main. Si tu utilises l'API d'OpenAI ou que tu as une architecture locale avec LiteLLM, ça s'intègre parfaitement bien.

Tu l'installes avec pip :

pip install "openai-agents[litellm]"

Tu crées un agent qui va utiliser un modèle exposé par LiteLLM et un outil personnalisé, ici une fonction Python qui retourne la météo.

N'importe quelle fonction avec le décorateur @function_tool peut être utilisée.

L'important pour que l'agent s'en sorte facilement est d'utiliser le typage optionnel avec mypy, ty ou pyright. Et de bien documenter la fonction avec une docstring valide.

from __future__ import annotations
import asyncio
from agents import Agent, Runner, function_tool, set_tracing_disabled
from agents.extensions.models.litellm_model import LitellmModel

@function_tool
def get_weather(city: str) -> str:
    """
    Get the weather for a city.
    Args:
        city (str): The city to get the weather for.
    Returns:
        str: The weather in the city.
    """
    return f"The weather in {city} is sunny."


async def main():
    agent = Agent(
        name="Assistant",
        instructions="You only respond in haikus.",
        model=LitellmModel(base_url="https://mylitellm", model="qwen3", api_key="S3CRET"),
        tools=[get_weather],
    )
    result = await Runner.run(agent, "What's the weather in Tokyo?")
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

Si tu veux gérer plusieurs agents, tu peux utiliser le paramètre handoffs.

Par exemple, on a un agent de booking, un agent de remboursement et un agent de triage qui va rediriger les questions vers le bon agent en fonction du sujet.

from agents import Agent

booking_agent = Agent(...)
refund_agent = Agent(...)

triage_agent = Agent(
    name="Triage agent",
    instructions=(
        "Help the user with their questions. "
        "If they ask about booking, hand off to the booking agent. "
        "If they ask about refunds, hand off to the refund agent."
    ),
    handoffs=[booking_agent, refund_agent],
)

Et voilà, tu as un bon premier aperçu des agents avec ces deux bibliothèques sympas.

Si ça t'intéresse, on pourra aller plus loin dans un prochain article avec la gestion de workflows complets.

Notia

Pour appréhender un peu tout ça, je me suis amusé à créer un outil appelé Notia, qui est un assistant de prise de notes basé sur un agent avec des outils.

J'y ai défini un certain nombre de fonctions que l'agent est capable d'utiliser pour gérer les notes de l'utilisateur, ainsi qu'un prompt système qui permet à l'agent de les utiliser convenablement.

agent = Agent(
    name="Notia",
    instructions=dedent("""
        /no_think

        You are Notia, a powerful AI assistant designed to be a developer's second brain.

        Your purpose is to help manage project-related notes, ideas, tasks, and code snippets.

        You have access to a set of tools to add, list, delete, and search notes in a vector database.

        Be helpful, concise, and proactive. When a user asks a question, use your search tool to find
        the most relevant notes to answer it.

        Pay close attention to the 'Rerank Score' provided by the search tool;
        a higher score indicates greater relevance to the query.
    """),
    model=LitellmModel(base_url="https://mylitellm", model="qwen3", api_key="S3CRET"),
    tools=[
        add_note,
        list_all_notes,
        delete_note,
        search_notes,
        edit_note,
        get_note_by_id,
        search_notes_by_project,
        list_all_projects,
        export_notes_by_project_to_csv,
        analyze_all_notes,
        extract_top_keywords,
    ]
)

On gère une session SQLite qui permet de conserver l'historique de la conversation et de la passer dans le contexte à l'exécution de la requête.

session = SQLiteSession("notia")

Avec ça, je lui envoie des messages (query) du type

"Ajoute une note pour mon projet X avec comme contenu Y"
"Liste moi toutes les notes que j'ai sur le projet X"
"Supprime la note avec l'ID X"
"Cherche dans mes notes tout ce qui parle de X"
"Extrait les mots-clés de mes notes"

On l'exécute et ça marche tout seul :

response = await Runner.run(agent, query, session=session)

Certaines des fonctions sont même écrites en Rust à l'aide de Maturin pour le fun et la performance.

Have fun !

Maturin : Booster Python avec du Rust

2025-09-01T00:00:00+02:00

La plupart des librairies Python actuelles qui sont à la mode comme pydantic, ruff ou uv sont écrites en grande partie en Rust pour des raisons de performance. Mais comment ont-ils géré cette intégration ?

La solution se situe dans un outil ultra pratique appelé Maturin qui permet de créer des extensions Python en Rust de manière très simple. L'idée derrière maturin est de compiler le code Rust en librairie Python directement utilisable.

Un peu comme CPython qui fait du binding entre le code C et Python, PyO3 (une dépendance de maturin) fait du binding entre Rust et Python.

Création d'un projet Python

Tu peux commencer par créer un projet Python classique avec un environnement virtuel.

On va utiliser uv qu'on a vu sur l'article précédent.

uv init myrustapp -p 3.13
cd myrustapp
uv venv -p 3.13
source .venv/bin/activate

Installation de maturin

On va maintenant installer maturin dans notre environnement virtuel.

uv add maturin

Et c'est tout !

Création du projet Rust

Pour créer le projet Rust, on va utiliser maturin init qui va nous créer notre librairie Rust avec tout ce qu'il faut dans le Cargo.toml pour faire le lien avec Python.

maturin init --bindings pyo3 myrustlib
cd myrustlib
maturin develop

Avec maturin develop, on compile la librairie et on l'installe directement dans notre environnement virtuel.

Une fois le développement terminé, il vaut mieux utiliser maturin develop -r pour créer la librairie en mode release pour de meilleures performances.

Il est également possible de builder et de déployer sur PyPI la librairie avec maturin build -r et maturin publish.

Le code Rust

Ok maintenant qu'on a notre workflow opérationnel, on va jeter un oeil au code Rust dans src/lib.rs.

use pyo3::prelude::*;

/// Formats the sum of two numbers as string.
#[pyfunction]
fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
    Ok((a + b).to_string())
}

/// A Python module implemented in Rust.
#[pymodule]
fn myrustlib(m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(sum_as_string, m)?)
    Ok(())
}

On va rapidement détailler le code afin que tu puisses le modifier et l'étendre.

Les deux macros #[pyfunction] et #[pymodule] sont fournies par PyO3 pour faire le lien entre Rust et Python.

Pour toutes les fonctions que tu veux exposer à Python, tu utiliseras #[pyfunction]. Si tes paramètres de fonctions sont des types natifs Python (int, str, list, dict...) tu n'as rien de plus à faire.

Il te suffit alors d'ajouter les fonctions au module Python via m.add_function dans la macro #[pymodule].

Si tu veux utiliser des types Rust plus complexes, tu peux utiliser les types fournis par PyO3 comme PyList ou PyDict.

Et voilà, tu peux maintenant utiliser n'importe quel code Rust dans ton projet Python. N'oublie pas de recompiler avec maturin develop -r à chaque modification.

Accélérer NumPy

Pour le ML, tu peux utiliser rust-numpy qui fait le lien entre les tableaux NumPy et les tableaux Rust.

use numpy::ndarray::{ArrayD, ArrayViewD, ArrayViewMutD};
use numpy::{IntoPyArray, PyArrayDyn, PyReadonlyArrayDyn, PyArrayMethods};
use pyo3::{pymodule, types::PyModule, PyResult, Python, Bound};

#[pymodule]
fn rust_ext<'py>(_py: Python<'py>, m: &Bound<'py, PyModule>) -> PyResult<()> {
    // example using immutable borrows producing a new array
    fn axpy(a: f64, x: ArrayViewD<'_, f64>, y: ArrayViewD<'_, f64>) -> ArrayD<f64> {
        a * &x + &y
    }

    // example using a mutable borrow to modify an array in-place
    fn mult(a: f64, mut x: ArrayViewMutD<'_, f64>) {
        x *= a;
    }

    // wrapper of `axpy`
    #[pyfn(m)]
    #[pyo3(name = "axpy")]
    fn axpy_py<'py>(
        py: Python<'py>,
        a: f64,
        x: PyReadonlyArrayDyn<'py, f64>,
        y: PyReadonlyArrayDyn<'py, f64>,
    ) -> Bound<'py, PyArrayDyn<f64>> {
        let x = x.as_array();
        let y = y.as_array();
        let z = axpy(a, x, y);
        z.into_pyarray(py)
    }

    // wrapper of `mult`
    #[pyfn(m)]
    #[pyo3(name = "mult")]
    fn mult_py<'py>(a: f64, x: &Bound<'py, PyArrayDyn<f64>>) {
        let x = unsafe { x.as_array_mut() };
        mult(a, x);
    }

    Ok(())
}

Dans la plupart des cas, NumPy est suffisamment performant. Mais tu n'es jamais à l'abri de tomber sur un cas critique où une petite partie de l'application nécessite un boost de performance.

Avec maturin, tu t'évites de devoir réécrire tout le projet en Rust pour te concentrer uniquement sur la partie concernée.

Quand utiliser Rust dans Python ?

Dans la plupart des cas classiques, tu n'auras pas besoin de coder en Rust.

Mais dès que tu vas devoir manipuler des milliers ou millions de données, et que tu te rends compte que Pandas ne suffit plus niveau vitesse, tu pourras coder la partie critique en Rust.

Typiquement, toute opération de filtrage, de transformation, d'agrégation, ou de calcul sur des milliers de données pourra être profondément accélérée. Tu vas passer de plusieurs secondes à quelques millisecondes.

Par exemple, je l'ai utilisé pour un projet personnel pour analyser et compter le nombre de mots clés dans des milliers de notes en excluant des stop words.

Le module mod stop_words ne contient qu'une liste de stop words dans différentes langues du type :

pub const STOP_WORDS: &[&str] = &["le", "la", "les", "un", "une", "de", "des", "et", "à", "en"];

Et notre fichier lib.rs complet est le suivant :

use pyo3::prelude::*;
use regex::Regex;
use serde::Deserialize;
use std::collections::{HashMap, HashSet};

mod stop_words;

#[derive(Deserialize, Debug)]
struct Note {
    id: String,
    content: String,
    project: String,
}

#[pyfunction]
fn analyze_notes_content(notes_json: &str) -> PyResult<String> {
    let notes: Vec<Note> = serde_json::from_str(notes_json).map_err(|e| {
        PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("Failed to parse JSON: {}", e))
    })?;

    let mut total_words = 0;
    let mut unique_projects = HashSet::new();

    for note in &notes {
        total_words += note.content.split_whitespace().count();
        if !note.project.is_empty() {
            unique_projects.insert(&note.project);
        }
        let _ = &note.id;
    }

    let analysis_result = format!(
        "Analyzed {} notes. Total word count: {}. Found {} unique projects.",
        notes.len(),
        total_words,
        unique_projects.len()
    );

    Ok(analysis_result)
}

#[pyfunction]
fn extract_keywords(notes_json: &str, top_n: usize) -> PyResult<String> {
    let notes: Vec<Note> = serde_json::from_str(notes_json).map_err(|e| {
        PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("Failed to parse JSON: {}", e))
    })?;

    let mut word_counts: HashMap<String, usize> = HashMap::new();
    let re = Regex::new(r"[^a-zA-ZÀ-ÿ\s]").map_err(|e| {
        PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("Failed to compile regex: {}", e))
    })?;

    let stop_words_set: HashSet<&str> = stop_words::STOP_WORDS.iter().cloned().collect();

    for note in notes {
        let lowercased_content = note.content.to_lowercase();
        let contraction_re = Regex::new(r"\b[dlcjntsqu]'").unwrap();
        let without_contractions = contraction_re.replace_all(&lowercased_content, "");
        let cleaned_content = re.replace_all(&without_contractions, "");
        for word in cleaned_content.split_whitespace() {
            if !stop_words_set.contains(word) && word.len() > 1 {
                // Ignore single-character words
                *word_counts.entry(word.to_string()).or_insert(0) += 1;
            }
        }
    }

    let mut sorted_keywords: Vec<(&String, &usize)> = word_counts.iter().collect();
    sorted_keywords.sort_by(|a, b| b.1.cmp(a.1)); // Sort by count, descending

    let top_keywords: Vec<String> = sorted_keywords
        .into_iter()
        .take(top_n)
        .map(|(word, count)| format!("\"{}\": {}", word, count))
        .collect();

    Ok(format!("{{{}}}", top_keywords.join(", ")))
}

#[pymodule]
fn notia_analyzer(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(analyze_notes_content, m)?)?;
    m.add_function(wrap_pyfunction!(extract_keywords, m)?)?;
    Ok(())
}

L'important ici c'est que la structure Note est commune entre Python et Rust et désérialisée avec serde.

Côté Python, j'ai juste alors récupéré mes notes au format JSON et appelé les deux fonctions de cette manière :

import json
from notia_analyzer import analyze_notes_content, extract_keywords

with open("notes.json", "r") as f:
    notes_json = f.read()

analysis = analyze_notes_content(notes_json)
print(analysis)

top_keywords = extract_keywords(notes_json, top_n=10)
print(top_keywords)

À garder dans un coin de sa tête pour les projets futurs !

Mon environnement python en 2025

2025-08-25T00:00:00+02:00

Après trois ans sans toucher à Python, il est temps de faire une mise à jour sur les outils pratiques pour un environnement de développement. Pas mal de choses ont changé depuis l'article de 2022, et un nouveau venu, Astral a tout chamboulé en proposant des outils ultra-performants écrits en Rust.

Versions de python, environnement virtuel et packaging

uv est un formidable outil tout-en-un qui remplace pyenv et poetry.

Tu l'installes via :

curl -LsSf https://astral.sh/uv/install.sh | sh

Pour installer une version de python, rien de plus simple avec la commande suivante :

uv python install 3.13

Et pour ensuite créer un projet avec un environnement virtuel spécifique avec :

uv init myapp -p 3.13
cd myapp
uv venv -p 3.13
source .venv/bin/activate

Tu peux alors ajouter des librairies, exécuter des scripts, builder et publier ton projet sur PyPI avec :

uv add requests
echo 'print("Hello World!")' > main.py
uv run python main.py
uv build
uv publish

L'outil utilise par défaut pyproject.toml pour les dépendances, s'inscrivant dans la lignée de poetry qui a popularisé ce format.

L'outil permet également d'installer les dépendances à la main avec un bon vieux requirements.txt via la commande :

uv pip install -r requirements.txt

Il permet de gérer un lockfile comme pour npm, de gérer du cache et d'autres petites choses plutôt cool. En plus niveau performance c'est vraiment très rapide.

Formatage du code

On utilisait black et isort, mais ruff fusionne maintenant le meilleur des deux mondes pour devenir le couteau suisse du linting et du formatage.

Tu l'ajoutes en dépendances dans ton projet avec uv :

uv add ruff --dev

Pour faire du linting, c'est :

uv run ruff check

Et pour formatter, c'est :

uv run ruff format

On garde la configuration par défaut qui est très bien, pas besoin de se prendre la tête.

Typage statique

Pour le typage, j'utilisais mypy, que j'ai ensuite délaissé pour pyright, mieux intégré aux éditeurs comme VS Code.

Mais Astral planche actuellement sur un concurrent appelé ty qui est encore en version beta mais qui est très prometteur. J'ai déjà sauté le pas : mon usage du typage est assez simple et, pour l'instant, l'outil fait parfaitement l'affaire. En tout cas niveau performance, par rapport aux deux autres, il n'y a pas photo.

Comme pour ruff, tu l'ajoutes à ton projet avec uv :

uv add ty --dev

Et tu lances la vérification du typage avec :

uv run ty check

Les trois outils ruff, ty et uv sont très bien intégrés dans vscode via les extensions officielles.

Franchement, merci Astral ! J'ai hâte de voir vos prochaines sorties.

Tests unitaires

Encore rien de neuf sous le soleil, on utilise toujours pytest :

uv add pytest --dev
uv run pytest

Développement web

Ces dernières années, un poids lourd a fait son apparition : fastapi. Il a détrôné django, flask et bottle en termes d'usage et de performance.

C'est devenu également mon choix par défaut. Il est simple et efficace comme on veut, permet de faire du sync et de l'async, et surtout génère automatiquement la documentation openapi ! Il se base sur pydantic pour la validation des données, qui est aussi une petite librairie intéressante à connaitre.

Au niveau du code ça ressemble à ça, ultra clean :

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: Union[bool, None] = None


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}

JIT

Python 3.13 introduit un compilateur JIT pour pallier l'un de ses gros points faibles : les performances. Pour le moment, ce n'est pas encore complètement au point, mais il faut savoir que numba propose déjà un compilateur JIT plutôt efficace pour améliorer les performances de certaines fonctions.

Ça s'utilise de cette façon :

from numba import jit

@jit
def somme(n):
    total = 0
    for i in range(n):
        total += i
    return total

print(somme(10000000))

Ça permet d'améliorer les performances de certaines fonctions de manière significative, sans pour autant devoir réécrire tout le code en C ou Rust.

Au final, les outils convergent et l'écosystème Python se simplifie autour d'un consensus. C'est une excellente nouvelle.

Mettre en place une architecture LLM OpenAI-compatible

2025-07-22T00:00:00+02:00

On va voir comment mettre en place une architecture de LLMs compatible avec l'API d'OpenAI, en utilisant des outils comme vLLM, Ollama, Infinity, Speaches et LiteLLM. De ce faire, ton service sera utilisable avec n'importe quelle application ou librairie qui se base sur l'API d'OpenAI.

Je ne vais pas rentrer dans le détail concernant l'installation de chaque brique, car tu trouveras facilement les informations nécessaires sur leurs sites officiels, et il existe déjà tout un tas de tutoriels sur le sujet. On va juste se contenter de les déployer avec Docker.

Docker compose

On initie un fichier docker-compose.yml pour orchestrer le déploiement de nos services, qu'on va alimenter au fur et à mesure. Voici la structure de base de notre fichier, avec le réseau et les volumes que nous utiliserons. On va tout mettre dans le même docker compose pour plus de clarté dans cet article, mais tu pourras le découper en morceaux si tu souhaites déployer plusieurs services sur plusieurs machines.

version: '3.8'

networks:
  vllm:
    name: vllm
    external: true

services:
    # On va ajouter nos services ici au fur et à mesure

volumes:
    huggingface_data:
    ollama_data:
    infinity_data:
    speaches_data:
    postgresql_data:
    redis_data:

On crée un réseau externe qu'on appelle vllm, qui va nous permettre de connecter nos services entre eux. Bien sûr en amont de tout ça il te faut Docker, Docker Compose, Cuda et les drivers NVIDIA installés sur ta machine.

Tu le crées via :

docker network create \
--driver bridge \
--subnet 192.168.0.0/24 \
--gateway 192.168.0.1 \
vllm

LLM principal

On attaque avec le déploiement de notre LLM principal :

Qwen 3 30B A3B est un modèle plutôt intéressant actuellement avec son mode de reasoning
vLLM est le serveur d'inférence le plus populaire et le plus simple à mettre en place pour de la production

On ajoute le service dans notre docker-compose.yml :

vllm:
  image: vllm/vllm-openai:v0.9.2
  restart: always
  runtime: nvidia
  environment:
    NVIDIA_VISIBLE_DEVICES: "all"
    HUGGING_FACE_HUB_TOKEN: "your_huggingface_token"
    VLLM_API_KEY: "your_vllm_api_key"
  volumes:
    - "huggingface_data:/root/.cache/huggingface"
  command: "--disable-log-stats --disable-log-requests --model 'Qwen/Qwen3-30B-A3B-FP8' --max-model-len 131072 --gpu-memory-utilization 0.8 --swap-space 8 --kv-cache-dtype 'auto' --enable-auto-tool-choice --tool-call-parser 'hermes' --enable-reasoning --reasoning-parser 'deepseek_r1' --rope-scaling '{\"rope_type\":\"yarn\",\"factor\":4.0,\"original_max_position_embeddings\":32768}'"
  shm_size: 32g
  networks:
    - vllm
  healthcheck:
    test: ["CMD", "curl", "-sf", "http://localhost:8000/metrics"]
    interval: 60s
    timeout: 30s
    retries: 5

Au niveau des options de vLLM :

on désactive les logs des requêtes pour éviter de polluer les logs
on utilise le max de la taille de contexte du modèle à l'aide de rope
on active le reasoning et le tooling
on utilise 80% du GPU pour laisser de la place pour les autres services tout en lui donnant assez de mémoire pour être tranquille

On mettra systématiquement en place un healthcheck pour monitorer les services.

LLM secondaire

On va désormais déployer un service Ollama pour nos LLMs secondaires. Ollama n'est pas vraiment prévu pour gérer beaucoup d'utilisateurs en parallèle, mais il va permettre de faire des tests avec d'autres modèles pour prototyper par exemple. Ça reste un outil intéressant mais il faut juste garder en tête que lorsque tu veux vraiment des performances, bascule sur vLLM.

On ajoute le service dans notre docker-compose.yml :

ollama:
  image: ollama/ollama:0.9.6
  restart: always
  runtime: nvidia
  environment:
    NVIDIA_VISIBLE_DEVICES: "all"
    OLLAMA_KV_CACHE_TYPE: "q8_0"
    OLLAMA_KEEP_ALIVE: "24h"
    OLLAMA_MAX_LOADED_MODELS: "2"
    OLLAMA_FLASH_ATTENTION: "1"
  volumes:
    - ollama_data:/root/.ollama
  shm_size: 2g
  networks:
    - vllm
  healthcheck:
    test: ["CMD", "ollama", "list", "||", "exit", "1"]
    interval: 60s
    timeout: 30s
    retries: 5

On quantifie le KV cache et on active le flash attention pour améliorer les performances.

Et après à travers ton container, tu pourras pull des modèles, ici par exemple on va mettre un modèle Vision :

ollama pull qwen2.5vl:7b-q4_K_M

Embedding et reranking

Pour faire du RAG, tu vas avoir besoin d'un modèle d'embedding afin d'alimenter ta base de données vectorielle type Qdrant ainsi qu'un modèle de reranking pour améliorer la pertinence des résultats.

Personnellement j'utilise Infinity qui est un petit service dédié à ces modèles. Certains partent sur TGI de Hugging Face qui peut aussi faire l'affaire.

On ajoute le service dans notre docker-compose.yml :

infinity:
  image: michaelf34/infinity:0.0.76
  restart: always
  runtime: nvidia
  environment:
    NVIDIA_VISIBLE_DEVICES: "all"
    DO_NOT_TRACK: "1"
    INFINITY_ANONYMOUS_USAGE_STATS: "0"
  volumes:
    - infinity_data:/app/.cache
  command: v2 --model-id 'BAAI/bge-reranker-v2-m3' --model-id 'nomic-ai/nomic-embed-text-v1.5' --port 7997
  shm_size: 2g
  networks:
    - vllm
  healthcheck:
    test: ["CMD", "curl", "-sf", "http://localhost:7997/health"]
    interval: 60s
    timeout: 30s
    retries: 5

Infinity est intéressant car il permet de déployer plusieurs modèles en même temps. Ici on utilise nomic pour l'embedding et BGE pour le reranking.

Text-to-speech et Speech-to-text

Speaches est un service qui permet de déployer des modèles TTS et STT en mode OpenAI-compatible. Il te permettra d'utiliser les routes /audio/transcriptions et /audio/speech.

On ajoute le service dans notre docker-compose.yml :

speaches:
  image: ghcr.io/speaches-ai/speaches:0.8.2-cuda-12.6.3
  restart: always
  runtime: nvidia
  environment:
    NVIDIA_VISIBLE_DEVICES: "all"
    LOG_LEVEL: "INFO"
  volumes:
    - speaches_data:/home/ubuntu/.cache/huggingface/hub
  shm_size: 2g
  networks:
    - vllm
  healthcheck:
    test: ["CMD", "curl", "-sf", "http://localhost:8000/health"]
    interval: 60s
    timeout: 30s
    retries: 5

Depuis le container, tu pourras récupérer faster-whisper pour le STT et piper pour le TTS via :

huggingface-cli download speaches-ai/piper-fr_FR-siwis-medium
huggingface-cli download Systran/faster-whisper-small

Orchestration avec LiteLLM

Et voilà, tu as tous tes services prêts à être orchestrés.

Ok maintenant qu'on a nos différents services, on va les orchestrer avec LiteLLM.

LiteLLM va se charger de faire le routage des requêtes OpenAI vers les services adéquats, en fonction de la route demandée.

On imagine que tu crées le fichier de configuration suivant dans /root/litellm/config.yaml :

general_settings:
  master_key: your_master_key
  proxy_batch_write_at: 60
  database_connection_pool_limit: 10

model_list:
  # Notre LLM principal
  - model_name: qwen3
    model_info:
      max_tokens: 65536
      max_input_tokens: 65536
      max_output_tokens: 65536
    litellm_params:
      model: hosted_vllm/Qwen/Qwen3-30B-A3B-FP8
      api_base: http://vllm:8000
      api_key: your_vllm_api_key
  # Notre LLM secondaire
  - model_name: qwen2.5-vl
    model_info:
      max_tokens: 16384
      max_input_tokens: 16384
      max_output_tokens: 16384
    litellm_params:
      model: ollama/qwen2.5vl:7b-q4_K_M
      api_base: http://ollama:11434
  # Embedding et reranking
  - model_name: nomic
    litellm_params:
      model: infinity/nomic-ai/nomic-embed-text-v1.5
      api_base: http://infinity:7997
    model_info:
      mode: embedding
  - model_name: bge-reranker
    litellm_params:
      model: infinity/BAAI/bge-reranker-v2-m3
      api_base: http://infinity:7997
    model_info:
      mode: rerank
  # TTS et STT
  - model_name: whisper
    litellm_params:
      model: openai/Systran/faster-whisper-small
      api_base: http://speaches:8000
    model_info:
      mode: audio_transcription
  - model_name: piper
    litellm_params:
      model: openai/speaches-ai/piper-fr_FR-siwis-medium
      api_base: http://speaches:8000
    model_info:
      mode: audio_speech

litellm_settings:
  num_retries: 3
  request_timeout: 3600
  fallbacks: []
  allowed_fails: 5
  cooldown_time: 30
  set_verbose: False
  json_logs: True
  cache: False
  drop_params: True
  telemetry: False

On a ici une configuration de base pour servir nos modèles. En amélioration, tu pourrais gérer des modèles de fallbacks et des limites en rpm et en tpm. Si tu as plusieurs cartes graphiques, tu peux dupliquer tes modèles dessus et liteLLM se chargera de faire la répartition de charge en fonction de la stratégie de routing que tu auras choisie.

On ajoute le service dans notre docker-compose.yml. Note qu'il nous faut un postgresql et un redis pour stocker les données de LiteLLM :

redis:
  image: redis:8
  restart: always
  networks:
    - vllm
  volumes:
    - redis_data:/data
  environment:
    REDIS_PASSWORD: "your_redis_password"
  command: ["redis-server", "--appendonly", "yes"]
  healthcheck:
    test: ["CMD", "redis-cli", "ping"]
    interval: 60s
    timeout: 30s
    retries: 5

postgres:
  image: postgres:17
  restart: always
  networks:
    - vllm
  environment:
    POSTGRES_USER: "your_postgres_user"
    POSTGRES_PASSWORD: "your_postgres_password"
    POSTGRES_DB: "your_postgres_db"
  volumes:
    - postgresql_data:/var/lib/postgresql/data
  healthcheck:
    test: ["CMD", "pg_isready", "-U", "your_postgres_user"]
    interval: 60s
    timeout: 30s
    retries: 5

litellm:
  image: ghcr.io/berriai/litellm:main-v1.74.0-stable
  container_name: litellm
  restart: always
  depends_on:
    - postgres
    - redis
  environment:
    - LITELLM_MODE=PRODUCTION
    - LITELLM_LOG=ERROR
    - LITELLM_SALT_KEY=your_salt_key
    - DATABASE_URL=postgresql://your_postgres_user:your_postgres_password@postgres:5432/your_postgres_db
    - REDIS_URL=redis://redis:6379/0
  ports:
    - "4000:4000"
  command: --config /app/config.yaml --telemetry False
  volumes:
    - /root/litellm/config.yaml:/app/config.yaml
  networks:
    - vllm
  healthcheck:
    test: ["CMD-SHELL", "wget --quiet --tries=1 http://localhost:4000/health/liveliness || exit 1"]
    interval: 60s
    timeout: 30s
    retries: 5

Et voilà, tu démarres tout ça et tu peux accéder à ton API OpenAI compatible sur http://localhost:4000.

Utilisation de l'API

Tu peux alors par exemple utiliser la librairie OpenAI en python ou utiliser curl directement pour faire des requêtes du type :

curl -X POST http://localhost:4000/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer your_master_key" \
-d '{
    "model": "qwen3",
    "messages": [
        {
            "role": "user",
            "content": "Hello, how are you?"
        }
    ]
}'

Tu peux utiliser les routes :

/chat/completions pour les modèles de chat avec qwen3 et qwen2.5-vl
/embeddings pour les modèles d'embeddings avec nomic
/rerank pour les modèles de reranking avec bge-reranker
/audio/transcriptions pour les modèles de transcription audio avec whisper
/audio/speech pour les modèles de synthèse vocale avec piper

Tu pourras aussi utiliser ton API sur des interfaces graphiques comme Open WebUI ou LibreChat. Étant OpenAI compatible, tu pourras l'utiliser dans des workflows d'agents comme N8N ou encore utiliser dans des librairies comme LangChain.

L'archi finale que tu pourras mettre en place pourra ressembler à ça :

Et voilà ! Tu disposes maintenant d'une architecture LLM complète, flexible et compatible avec l'écosystème OpenAI. N'hésite pas à expérimenter avec d'autres modèles et à adapter cette configuration à tes besoins. Bon déploiement !

Utiliser un LLM pour générer un compte-rendu stylisé en Markdown

2025-04-04T00:00:00+02:00

On enchaîne avec la suite de l'article sur Whisper et on va utiliser un LLM pour générer un compte-rendu stylisé en Markdown.

Précédemment, on avait utilisé Ollama pour faire tourner notre LLM. Histoire de changer, on va utiliser cette fois-ci vLLM, qui est une alternative qui se veut plus performante pour la production.

Par contre, il ne tourne que sous GPU, donc si tu n'as qu'un CPU, il te faudra rester sur Ollama.

vLLM

En amont, il te faudra avoir installé CUDA sur ton système. Ensuite, pour exécuter vLLM, on va utiliser le container Docker officiel. Il te faudra un token Hugging Face et définir une clé API pour vLLM.

docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    -e "HUGGING_FACE_HUB_TOKEN=S3CR3T" \
    -e "VLLM_API_KEY=S3CR3T" \
    -p 8000:8000 --ipc=host \
    vllm/vllm-openai:latest --model mlabonne/Daredevil-8B

On le lance ici avec le modèle Daredevil-8B, qui est un llama 3.1 Instruct amélioré et qui marche plutôt bien pour ce qu'on veut faire.

Tu peux tester qu'il tourne correctement en testant l'url :

curl http://localhost:8000/v1/models

Ok, notre LLM est prêt ! On va pouvoir modifier le code de notre application whisper pour améliorer le compte-rendu généré.

Il te faudra installer dans ton environnement virtuel la librairie openai :

pip install openai

En effet, l'api de vLLM est directement compatible avec l'api de OpenAI, donc tu peux utiliser la même librairie !

Tu reprends le fichier main.py du précédent article et tu vas modifier la fonction summarize pour y ajouter une étape de formatage des phrases récupérées par sumy en Markdown.

On prévoit donc l'utilisation d'une fonction format_summary pour le faire.

@st.cache_data
def summarize(text: str, num_sentences: int, language: str) -> str:
    summarize = summarize_text(text, num_sentences=num_sentences, language=language)
    format = format_summary(
        "http://localhost:8000",
        "S3CR3T",
        "mlabonne/Daredevil-8B",
        summarize,
        language=language,
    )
    return format


from openai import OpenAI

def format_summary(base_url: str, authtoken: str, model: str, summary: str, language="en") -> str:
    client = OpenAI(api_key=authtoken, base_url=base_url)

    prompt = f"""
    You are an advanced assistant specialized in summarizing meetings.
    Reformat the following summary into a structured meeting report **without changing or adding any information**.
    You must **only use the sentences provided**. Do not invent, modify, or infer any details.

    The output **should be in the following language**: {language.upper()}.

    Structure:
    - **Introduction**
    - **Points**
    - **Decisions**
    - **Actions**

    Ensure that all section titles are also in the same language as the output.

    **Raw Summary (Use only these sentences):**
    {summary}

    **Structured Meeting Report in Markdown:**
    """

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=4096,
        temperature=0.3,
    )

    return response.choices[0].message.content  # type: ignore

Toute l'intelligence de l'assistant est dans le prompt. Tu peux le modifier pour changer le style de ton compte-rendu.

Ici, on s'assure qu'il ne va utiliser que les phrases récupérées par sumy et qu'il ne va pas en inventer de nouvelles.

Lui spécifier la structure permet d'avoir des résultats homogènes lors de chaque génération.

On lui précise bien qu'on veut du Markdown en sortie et qu'il conserve la langue du résumé.

La température plutôt basse ici renforce l'idée de ne pas inventer d'informations.

Au début, sans ces recommandations, il m'inventait des dates de réunion, des noms de personnes, etc.

Certains LLMs sont plus performants que d'autres pour ce genre de tâche. Ici, Daredevil-8B fait le taf, mais j'imagine qu'il existe sûrement sur Hugging Face des modèles encore plus performants ! A toi de voir.

Tu relances streamlit et tu peux voir le résultat.

streamlit run main.py

Pour exemple, à partir de cette transcription :

Bonjour à tous, nous allons commencer la réunion pour savoir si nous allons changer notre parc de voiture ou pas.
Il faut savoir qu'il y a 5 voitures et il y en a 2 qui sont actuellement cassés.
Qu'est-ce qu'on fait ?
On va vendre les 2 voitures cassés et on va en acheter de nouvelles.
Jim, tu vas aller chez Renault et tu vas t'occuper de l'avance.
Jim, tu vas aller chez Mercedes et on va acheter de nouveaux véhicules pour compléter le parc.
C'est ok pour tout le monde.
Bien, je vous remets fin à la réunion.

On obtient le résumé stylisé suivant :

**Introduction**
Bonjour à tous, nous allons commencer la réunion pour savoir si nous allons changer notre parc de voitures ou pas.

**Points**
Il faut savoir qu'il y a cinq voitures et il y en a deux qui sont actuellement cassées.

**Decisions**
On va vendre les deux voitures cassées et on va en acheter deux nouvelles.

**Actions**
- Jim, tu vas aller chez Renault et tu vas t'occuper de la vente.
- John, tu vas aller chez Mercedes et on va acheter de nouveaux véhicules pour compléter le parc.

Pas si mal non ?

Développer une UI pour Whisper avec Streamlit

2025-04-03T00:00:00+02:00

Whisper est un modèle IA de speech-to-text créé par OpenAI et qui marche plutôt pas mal. L'outil est open source et s'utilise en ligne de commande directement. Il te permet de transcrire de l'audio en texte, de faire des traductions directes en anglais, de traduire des vidéos pour en générer des sous-titres, etc.

Mais pourquoi ne pas se faire une petite app avec streamlit, histoire de l'utiliser plus facilement et d'avoir une UI sympathique pour les utilisateurs ?

Prérequis

Bon, forcément, il te faut python. Pour cet article, j'ai utilisé la version 3.9 mais ça devrait marcher avec les versions plus récentes.

Tu te fais un environnement virtuel et tu installes les dépendances suivantes :

pip install openai-whisper
pip install streamlit
pip install pyannote.audio
pip install sumy

En gros, l'idée ici sera de permettre à l'utilisateur de faire une transcription d'un audio avec whisper, puis d'identifier automatiquement les personnes qui parlent avec pyannote (diarization), et enfin de sortir les phrases les plus importantes de la transcription pour en faire un résumé avec sumy.

Développement

Tu peux te créer un fichier main.py pour ton app streamlit et on va attaquer le code.

On commence par télécharger nltk qui sera nécessaire pour sumy, pour la tokenisation des phrases.

import nltk
nltk.download("punkt", quiet=True)
nltk.download("punkt_tab", quiet=True)

Ensuite on met un titre et on affiche un selectbox pour choisir le modèle whisper ainsi qu'une checkbox pour activer la diarization.

import streamlit as st
st.title("Compte-rendu de réunion")

WHISPER_MODEL_OPTIONS = ["tiny", "base", "small", "medium", "large", "turbo"]
selected_model = st.selectbox("Choisissez la précision de l'analyse :", WHISPER_MODEL_OPTIONS, index=1)
diarization_enabled = st.checkbox("🔍 Identifier les différents intervenants", value=False)

On charge alors le modèle whisper et le modèle pyannote en cache pour améliorer les performances. Note qu'il te faut un token Hugging Face pour pyannote. On prend également en compte CUDA pour utiliser le GPU si tu en as un. Pour installer CUDA, je te laisse voir directement avec la documentation officielle.

import whisper
import torch
from pyannote.audio import Pipeline

@st.cache_resource
def load_whisper_model(model_name: str) -> whisper.Whisper:
    device = "cuda" if torch.cuda.is_available() else "cpu"
    return whisper.load_model(model_name, device=device)


@st.cache_resource
def load_diarization_model() -> Pipeline:
    access_token = "ton-token-huggingface"
    pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization-3.1", use_auth_token=access_token)
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    pipeline.to(device)
    return pipeline


model = load_whisper_model(selected_model)
diarization_model = load_diarization_model() if diarization_enabled else None

Ensuite, on propose à l'utilisateur s'il veut utiliser son micro ou uploader un fichier audio.

input_option = st.radio(
    "Comment souhaitez-vous ajouter l'audio ?", ("📂 Télécharger un fichier", "🎤 Utiliser le micro")
)

On gère également la transcription et le résumé en session pour éviter que streamlit ne relance les fonctions à chaque fois qu'il est rafraîchi par un clic sur un bouton.

if "transcription_result" not in st.session_state:
    st.session_state.transcription_result = None
    st.session_state.summary = None

if "previous_input_option" in st.session_state and st.session_state.previous_input_option != input_option:
    st.session_state.transcription_result = None
    st.session_state.summary = None

st.session_state.previous_input_option = input_option

On attaque maintenant du lourd, la fonction de transcription.

from typing import Any

@st.cache_data
def transcribe_audio(file_path: str) -> dict:
    return model.transcribe(file_path, language=None)

@st.cache_data
def diarize_audio(file_path: str) -> Any:
    return diarization_model(file_path) if diarization_model is not None else None

import torchaudio
import torchaudio.transforms as T
import copy
import os
from functools import cache

@cache
def get_random_name(speaker: str) -> str:
    """
    Return a random name for the speaker.
    """
    names = [
        "Alice",
        "Bob",
        "Charlie",
        "David",
        "Emma",
        "Fanny",
        "Gaston",
        "Hugo",
        "Isabelle",
        "Jules",
    ]
    index = int(speaker.split("_")[-1])
    return names[index] if index < len(names) else f"Locuteur {index}"

def assign_speakers(transcription: dict, diarization: Any) -> dict:
    new_transcription = copy.deepcopy(transcription)

    for seg in new_transcription["segments"]:
        max_overlap = 0
        assigned_speaker = None

        for turn, _, speaker in diarization.itertracks(yield_label=True):
            overlap_start = max(seg["start"], turn.start)
            overlap_end = min(seg["end"], turn.end)
            overlap_duration = max(0, overlap_end - overlap_start)
            seg_duration = seg["end"] - seg["start"]

            overlap_ratio = overlap_duration / seg_duration

            if overlap_ratio > max_overlap:
                max_overlap = overlap_ratio
                assigned_speaker = speaker

        if assigned_speaker:
            seg["speaker"] = get_random_name(assigned_speaker)

    return new_transcription

def convert_and_resample_audio(input_path: str, output_path: str, target_sr=16000) -> None:
    waveform, sr = torchaudio.load(input_path)
    if sr != target_sr:
        resampler = T.Resample(orig_freq=sr, new_freq=target_sr)
        waveform = resampler(waveform)
    torchaudio.save(output_path, waveform, target_sr)

def process_transcription(tmp_filename: str) -> None:
    resampled_audio = None
    try:
        st.write("⏳ Analyse en cours... Prenez un café ☕")

        transcription = transcribe_audio(tmp_filename)

        if diarization_enabled:
            st.write("🔍 Identification des intervenants en cours...")
            resampled_audio = tmp_filename.rsplit(".", 1)[0] + "_resampled.wav"
            convert_and_resample_audio(tmp_filename, resampled_audio)
            diarization = diarize_audio(resampled_audio)
            transcription = assign_speakers(transcription, diarization)

        st.session_state.transcription_result = transcription
        st.session_state.summary = None

    except Exception as e:
        st.error(f"❌ Erreur pendant la transcription/diarisation : {str(e)}")
    finally:
        os.remove(tmp_filename)
        if diarization_enabled and resampled_audio is not None:
            os.remove(resampled_audio)

Bon, avant de passer à la suite, on va prendre du temps pour détailler tout ça.

La fonction process_transcription commence par transcrire l'audio avec whisper.

Puis, si on a la diarization d'activée, il nous faut d'abord resampler l'audio à 16kHz pour que pyannote puisse le traiter. Pyannote va alors analyser l'audio pour nous envoyer les différents segments avec les intervenants identifiés.

Enfin, on assigne les intervenants aux segments audio de whisper.

On essaye de gérer le chevauchement des segments de pyannote avec les segments de whisper pour assigner le bon intervenant à chaque phrase.

On n'oublie pas de supprimer les fichiers temporaires à la fin et on met les résultats en session.

Maintenant qu'on a nos fonctions prêtes, on va pouvoir les appeler en fonction des 2 cas d'usages : micro ou upload de fichier.

import tempfile
import mimetypes

if input_option == "📂 Télécharger un fichier":
    uploaded_file = st.file_uploader("Déposez votre fichier audio ici", type=["mp3", "wav", "m4a"])

    if uploaded_file is not None:
        if st.button("📝 Transformer l'audio en texte"):
            file_extension = uploaded_file.name.split(".")[-1]
            mime_type, _ = mimetypes.guess_type(uploaded_file.name)
            if mime_type and mime_type.startswith("audio"):
                with tempfile.NamedTemporaryFile(delete=False, suffix=f".{file_extension}") as tmp_file:
                    tmp_file.write(uploaded_file.read())
                    tmp_filename = tmp_file.name
                process_transcription(tmp_filename)
            else:
                st.error("❌ Format non reconnu ! Merci d'ajouter un fichier audio valide.")

elif input_option == "🎤 Utiliser le micro":
    if "audio_data" not in st.session_state:
        st.session_state.audio_data = None
        st.write("🎤 Cliquez pour enregistrer votre réunion")

    audio_data = st.audio_input("Enregistrez votre message vocal")

    if audio_data:
        audio_bytes = audio_data.getvalue()
        st.session_state.audio_data = audio_bytes

        st.write("✅ Enregistrement terminé.")

    if "audio_data" in st.session_state and st.session_state.audio_data:
        if st.button("📝 Transformer l'audio en texte"):
            st.session_state.transcription_result = None
            st.session_state.summary = None
            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
                tmp_file.write(st.session_state.audio_data)
                tmp_filename = tmp_file.name
            process_transcription(tmp_filename)

Et voilà ! On peut alors afficher la transcription brute :

import json

if "transcription_result" in st.session_state and st.session_state.transcription_result:
    result = st.session_state.transcription_result
    detected_language = result["language"]
    text_transcription = result["text"]

    st.write(f"🌍 Langue détectée : **{detected_language}**")

    transcript = "\n".join(f"{seg['text']}" for seg in st.session_state.transcription_result["segments"])

    st.write("🗒️ Voici votre compte-rendu brut :")
    st.code(transcript, language="plaintext", height=200, wrap_lines=True)
    json_content = json.dumps(result, indent=4)

A partir de maintenant, tout le reste du code se trouvera dans le bloc du if "transcription_result" in st.session_state.

On propose également de la télécharger en JSON et en TXT :

col1, col2 = st.columns(2)
with col1:
    st.download_button("📄 Télécharger la transcription (TXT)", transcript, "transcription.txt", "text/plain")
with col2:
    st.download_button(
        "📝 Télécharger la version détaillée (JSON)", json_content, "transcription.json", "application/json"
    )

Et même chose si on a la diarization activée :

if diarization_enabled:
    st.write("🗣️ Transcription avec intervenants")

    transcript_with_speakers = "\n".join(
        f"[{seg['start']:.1f}s - {seg['end']:.1f}s] {seg.get('speaker', 'Speaker ?')}: {seg['text']}"
        for seg in st.session_state.transcription_result["segments"]
    )

    st.code(transcript_with_speakers, height=200, wrap_lines=True)

    st.download_button(
        "📑 Télécharger la version annotée avec les intervenants",
        transcript_with_speakers,
        "transcript_with_speakers.txt",
        "text/plain",
    )

Le plus gros est fait ! On peut maintenant passer à la génération du résumé. Pour se faire, on va utiliser sumy avec LexRank.

from sumy.parsers.plaintext import PlaintextParser
from sumy.nlp.tokenizers import Tokenizer
from sumy.summarizers.lex_rank import LexRankSummarizer

def summarize_text(text: str, num_sentences=5, language="french") -> str:
    try:
        tokenizer = Tokenizer(language)
    except Exception:
        raise ValueError(f"Langue non supportée par le tokenizer : {language}")

    parser = PlaintextParser.from_string(text, tokenizer)
    summarizer = LexRankSummarizer()
    summary = summarizer(parser.document, num_sentences)
    return " ".join(str(sentence) for sentence in summary)

@st.cache_data
def summarize(text: str, num_sentences: int, language: str) -> str:
    return summarize_text(text, num_sentences=num_sentences, language=language)

st.subheader("Synthèse du compte-rendu")

if "summary" not in st.session_state:
    st.session_state.summary = None

num_sentences = st.slider(
    "Choisissez le nombre de lignes pertinentes à extraire", min_value=1, max_value=50, value=10
)

if st.button("✨ Générer une synthèse"):
    try:
        st.write("⏳ Analyse en cours... Prenez un café ☕")
        summary = summarize(text_transcription, num_sentences=num_sentences, language=detected_language)
        st.session_state.summary = summary
    except ValueError as e:
        st.error(str(e))

if st.session_state.summary:
    st.code(st.session_state.summary, language="plaintext", height=200, wrap_lines=True)

    st.download_button(
        "📥 Télécharger la synthèse (Markdown)",
        st.session_state.summary,
        "synthese.md",
        "text/markdown",
    )

Et voilà ! On a une UI sympathique pour faire de la transcription et de la synthèse de texte.

Tu peux lancer ton app via :

streamlit run main.py

Le rendu final ressemble à ça :

En piste d'amélioration qu'on verra plus tard, on pourra utiliser les phrases extraites par sumy pour les passer à un LLM afin de générer un compte-rendu stylisé en Markdown.

Et voilà ! Plus besoin de prendre des notes pendant tes réunions, laisse whisper s'en charger !

Booster les performances de son RAG avec la quantification

2024-12-12T00:00:00+01:00

Dans mon article précédent, tu as découvert comment mettre en place un RAG pour recommander des films. On avait utilisé un petit fichier JSON pour stocker les films, mais imagine maintenant que ton RAG doive parcourir des millions de documents. Là, tu vas vite voir que les requêtes deviennent de plus en plus longues et que la mémoire explose.

La bonne nouvelle, c’est qu’avec la quantification, tu peux réduire significativement la taille des embeddings, ce qui améliore la performance.

Tweaking de SentenceTransformer avec la quantification

Reprends ton projet de RAG et tweake SentenceTransformers pour intégrer la quantification binaire. La modification est simple et se résume à une ligne :

def generate_embeddings(model, content):
    """Génère des embeddings pour un contenu donné avec quantification binaire."""
    return model.encode(content, precision="binary")

On ajoute precision="binary" lors de l'encodage du contenu. Mais concrètement, qu’est-ce que ça signifie ?

La précision "binary" implique qu’au lieu de stocker chaque valeur de l’embedding comme un nombre flottant (qui utilise 4 octets par valeur), chaque dimension est convertie en une valeur binaire (0 ou 1). Cela réduit la taille des embeddings d’un facteur 32 et accélère les recherches.

Gain de performance à quel prix ?

Grâce à cette méthode, tu réduis considérablement l’espace disque et la mémoire nécessaires pour stocker tes embeddings. Tu peux maintenant effectuer des recherches sur des millions de documents sans souci.

Un aperçu des différences entre les embeddings flottants et binaires en terme de taille :

>>> embeddings.shape
(2, 1024)
>>> embeddings.nbytes
8192
>>> embeddings.dtype
float32
>>> binary_embeddings.shape
(2, 128)
>>> binary_embeddings.nbytes
256
>>> binary_embeddings.dtype
int8

Mais il y a un mais : la perte de précision est l’un des inconvénients majeurs. La quantification est une méthode de compression, et donc les valeurs binaires ne peuvent pas contenir autant d’informations que les valeurs flottantes. Selon l’application, cela peut ne pas être adapté.

Pour un système de recherche de films, cette approche reste largement suffisante. En revanche, si tes embeddings doivent capter des nuances très fines, la quantification peut affecter la qualité des résultats.

À toi de décider si cette solution est adaptée à ton cas, mais c’est une technique intéressante à garder en tête.

Développer son propre RAG local avec Ollama, ChromaDB et Streamlit

2024-11-28T00:00:00+01:00

Bon, il est temps de se mettre à l'intelligence artificielle et aux LLMs. Ça fait un moment que j'utilise des outils comme GitHub Copilot et ChatGPT, mais sans vraiment savoir comment ça marche sous le capot.

On va commencer une série d'articles d'initiation aux LLMs pour un développeur, en découvrant petit à petit et en s'autorisant à faire des erreurs. Donc ne prenez pas ces articles comme le pinacle du développement IA, c'est juste une synthèse de mes explorations !

L'idée sera d'avoir nos propres LLMs locaux et de développer des outils dessus. Comme ça, on est sûr que nos données restent confidentielles et ne partent pas dans le cloud.

Prérequis

L'outil qui semble faire consensus pour avoir son LLM local est Ollama. Tu l'installes avec la commande suivante :

curl -fsSL https://ollama.com/install.sh | sh

Puis, tu peux tester le LLM de Facebook Llama3 via :

ollama run llama3.2

On ne va pas rentrer dans le détail de Ollama, car il y a déjà suffisamment de contenu que tu peux trouver un peu partout sur Internet. Sache que tu peux récupérer d'autres modèles comme Mistral, par exemple, et que tu peux même créer ton propre modèle à l'aide d'un fichier modelfile qui se veut être une sorte de Dockerfile, mais pour les LLMs.

Projet de RAG

De ce que j'ai compris, il existe deux manières d'améliorer un LLM :

Soit via du fine-tuning, où on apprend des choses en profondeur au LLM pour en modifier le comportement, mais qui nécessite des GPUs puissants.
Soit via du Retrieval-Augmented Generation (RAG), qui consiste à utiliser des bases de données vectorielles pour que le LLM puisse y puiser des informations.

On va commencer par la 2ème solution, qui semble plus simple et permet déjà des cas d'usage plutôt sympas.

Tu vas pouvoir créer un premier programme, qui consistera en une application de recommandations de films disponible dans une médiathèque.

Côté technos, on va utiliser ChromaDB pour stocker et indexer les films, Sentence-Transformers pour générer des embeddings, et Ollama pour faire les recommandations. Je te laisse gérer ton virtualenv comme tu l'entends.

python = "^3.12"
chromadb = "^0.5.20"
ollama = "^0.4.1"
sentence-transformers = "^3.3.1"
streamlit = "^1.40.2"

Charger les Données des Films

On commence par préparer les données des films. Imaginons que tu aies un fichier data/data.json qui contient des informations comme le titre du film, le synopsis, l'ID IMDb, etc.

[
    {
        "Title": "Interstellar",
        "Year": "2014",
        "Rated": "PG-13",
        "Released": "07 Nov 2014",
        "Runtime": "169 min",
        "Genre": "Adventure, Drama, Sci-Fi",
        "Director": "Christopher Nolan",
        "Writer": "Jonathan Nolan, Christopher Nolan",
        "Actors": "Ellen Burstyn, Matthew McConaughey, Mackenzie Foy, John Lithgow",
        "Plot": "A team of explorers travel through a wormhole in space in an attempt to ensure humanity's survival.",
        "Language": "English",
        "Country": "USA, UK",
        "Awards": "Won 1 Oscar. Another 39 wins & 134 nominations.",
        "Poster": "http://ia.media-imdb.com/images/M/MV5BMjIxNTU4MzY4MF5BMl5BanBnXkFtZTgwMzM4ODI3MjE@._V1_SX300.jpg",
        "Metascore": "74",
        "imdbRating": "8.6",
        "imdbVotes": "937,412",
        "imdbID": "tt0816692",
        "Type": "movie",
        "Response": "True",
        "Images": [
        "https://images-na.ssl-images-amazon.com/images/M/MV5BMjA3NTEwOTMxMV5BMl5BanBnXkFtZTgwMjMyODgxMzE@._V1_SX1500_CR0,0,1500,999_AL_.jpg",
        "https://images-na.ssl-images-amazon.com/images/M/MV5BMzQ5ODE2MzEwM15BMl5BanBnXkFtZTgwMTMyODgxMzE@._V1_SX1500_CR0,0,1500,999_AL_.jpg",
        "https://images-na.ssl-images-amazon.com/images/M/MV5BMTg4Njk4MzY0Nl5BMl5BanBnXkFtZTgwMzIyODgxMzE@._V1_SX1500_CR0,0,1500,999_AL_.jpg",
        "https://images-na.ssl-images-amazon.com/images/M/MV5BMzE3MTM0MTc3Ml5BMl5BanBnXkFtZTgwMDIyODgxMzE@._V1_SX1500_CR0,0,1500,999_AL_.jpg",
        "https://images-na.ssl-images-amazon.com/images/M/MV5BNjYzNjE2NDk3N15BMl5BanBnXkFtZTgwNzEyODgxMzE@._V1_SX1500_CR0,0,1500,999_AL_.jpg"
        ]
    }
]

Tu crées ton fichier de script Python et c'est parti.

Cette fonction va simplement charger les films depuis le fichier JSON et te permettra d’ajouter ces films dans ChromaDB.

import json
import ollama
from sentence_transformers import SentenceTransformer
import chromadb
from chromadb.config import Settings
import streamlit as st

def load_movies(file_path="data/data.json"):
    """Loads movie data from the JSON file."""
    with open(file_path, "r") as f:
        return json.load(f)

Initialiser ChromaDB

Ensuite, on initialise ChromaDB, une base de données qui te permettra de stocker les embeddings des films.

Hein ? Des embeddings ?

Concrètement, chaque mot de tes documents est converti en nombres (tokens), puis est inséré dans un vecteur qui sera stocké dans la base. Ensuite, la requête de l'utilisateur est également convertie en vecteur. Puis, il compare le vecteur de la requête avec les vecteurs en base pour donner les résultats les plus proches.

def initialize_chromadb():
    """Initializes and returns a ChromaDB client with a movie collection."""
    client = chromadb.Client(Settings(is_persistent=True, anonymized_telemetry=False))
    return client

Générer les Embeddings

On utilise Sentence-Transformer pour transformer chaque film en un vecteur d'embedding.

def generate_embeddings(model, content):
    """Generates embeddings for a given content."""
    return model.encode(content)

Indexer les Films

Une fois qu'on a les embeddings, on va les ajouter dans ChromaDB et on va indexer chaque film en utilisant son titre et son synopsis. Si un film est déjà dans l'index, on ne le réajoute pas. Si tu veux refaire complètement l'index, il te suffit d'effacer le dossier chroma.

def index_movies(movies, model, collection):
    """Indexes movies in ChromaDB only if the index doesn't exist already."""
    for movie in movies:
        doc_id = movie["imdbID"]
        title = movie["Title"]
        plot = movie["Plot"]
        content = f"{title}: {plot}"

        # Check if the document already exists
        existing_document = collection.get(ids=[doc_id])

        # If the document exists, skip it
        if existing_document["documents"]:
            print(
                f"The document with ID {doc_id} already exists. It will not be added."
            )
            continue

        # Generate the embedding
        embedding = generate_embeddings(model, content)

        # Add to the collection
        collection.add(
            ids=[doc_id],
            metadatas=[{"title": title, "year": movie["Year"]}],
            documents=[content],
            embeddings=[embedding],
        )
    print("Data indexed in ChromaDB.")

Rechercher dans ChromaDB

Maintenant, on va créer une fonction qui va effectuer la recherche dans ChromaDB en fonction de la requête de l'utilisateur. On va utiliser les embeddings de la requête pour chercher les films les plus pertinents dans la base de données. Ici, on récupère les 3 résultats les plus proches.

def perform_query(collection, model, query):
    """Performs a search in ChromaDB and returns the results."""
    query_embedding = generate_embeddings(model, query)
    results = collection.query(
        query_embeddings=[query_embedding],
        n_results=3,
    )
    return results

Générer un Prompt pour Ollama

Une fois que nous avons trouvé les films pertinents, on va générer un prompt pour Ollama afin qu’il nous recommande des films à partir des résultats de la recherche. Toute l'intelligence se situe au niveau de ce prompt. On donne un rôle de vendeur de DVD à Ollama, puis on lui donne en contexte la liste des films qui ont été récupérés dans ChromaDB. Enfin, on lui donne la requête de l'utilisateur et on le laisse générer le texte complet de la recommandation.

On insiste bien ici sur le fait qu'il ne peut pas proposer des films en dehors du contexte fourni.

def generate_prompt(context, query):
    """Generates a prompt for Ollama where the model acts as a DVD salesperson."""
    return f"""
You are a knowledgeable DVD salesperson with expertise in movies. Your task is to recommend movies to customers, but you can only suggest films that are available in the store's inventory. Make sure your recommendations are based solely on the list of movies provided.

Context: Below is a list of movies currently available in the store:
{context}

Customer's Question: Ask for a movie about {query}

Your Movie Recommendations (only from the available list):
"""

Interroger Ollama

Ensuite, on passe le prompt à Ollama pour obtenir ses recommandations.

def query_ollama(prompt, model_name="myllama"):
    """Queries Ollama with the given prompt."""
    client = ollama.Client()
    response = client.chat(model_name, messages=[{"role": "user", "content": prompt}])
    return response["message"]["content"]

Créer une Interface Utilisateur avec Streamlit

Enfin, on va utiliser Streamlit pour créer une interface utilisateur simple. J'ai découvert récemment cet outil et franchement, c'est magique. Ça te permet de générer très rapidement une interface web pour ton script sans faire d'HTML, de CSS ou de JavaScript.

L'utilisateur peut entrer une requête, et l'application va afficher les films pertinents, le prompt passé à Ollama et la réponse qu'il a générée.

def main():
    # Load the movies
    movies = load_movies()

    # Initialize SentenceTransformer to generate embeddings
    model = SentenceTransformer("all-MiniLM-L6-v2")

    # Initialize ChromaDB
    client = initialize_chromadb()

    # Check if the collection exists already
    collection = client.get_or_create_collection(name="movies")

    # If the collection is empty (does not exist), index the movies
    if not collection.count():
        print("Indexing movies in ChromaDB...")
        index_movies(movies, model, collection)
    else:
        print("The movie index already exists. It was not regenerated.")

    # Streamlit user interface
    st.title("Movie Recommendations")
    query = st.text_input("Ask for a movie about...", "a wormhole in space")

    if st.button("Ask"):
        if query:
            # Perform the search
            results = perform_query(collection, model, query)

            # Prepare the prompt for Ollama as the DVD salesperson
            documents = results.get("documents", [])
            if documents is None:
                documents = []

            # Display the results in the UI
            st.subheader("Movies Found")
            for doc in documents:
                st.write(doc)

            context = "\n".join(
                [f"- {doc}" for result in documents if result for doc in result]
            )
            prompt = generate_prompt(context, query)

            # Display the prompt in the UI
            st.subheader("Prompt Sent to Ollama")
            st.text_area("Here is the prompt sent to Ollama", prompt, height=200)

            # Show the loading spinner while the request is being processed
            with st.spinner("Searching..."):
                # Query Ollama
                response = query_ollama(prompt, model_name="llama3.2")

            st.subheader("Ollama's Recommendation")
            st.write(response)

if __name__ == "__main__":
    main()

Il te suffit d'exécuter tout ça et de tester pour voir le résultat via la commande :

streamlit run tonscript.py

Ici un aperçu sans les infos de debug :

Pour te simplifier la vie si tu veux juste tester ça, tu peux récupérer mon projet sur mon dépôt git. Tu y trouveras même une version alternative du script avec Qdrant à la place de ChromaDB pour l'indexation des films.

Quelques pistes d'amélioration:

Utiliser le modèle LaBSE de Sentence-Transformers pour des embeddings multilingues.
Utiliser un framework du type LlamaIndex ou LangChain pour gérer les embeddings et les requêtes.
Optimiser la recherche avec des filtres tels que le genre, l'année ou le réalisateur.
Enrichir les données des films avec une API externe (IMDb, TMDb).
Ajouter un mécanisme de feedback utilisateur pour affiner les recommandations.
Jouer avec le paramètre de temperature dans le prompt pour obtenir des recommandations plus ou moins originales.

Have fun !

Outils "Blazing-Fast" pour Linux écrits en Rust

2024-10-14T00:00:00+02:00

Depuis l'avènement de Rust et du fameux adage "Rewrite it in Rust", de nombreux outils système ont été réécrits en Rust pour bénéficier de meilleures performances dites blazing-fast, ainsi que d'une fluidité et d'une ergonomie plus modernes.

Il est temps de remplacer les classiques ls, cd, tmux, grep ou encore find par leurs jumeaux Rustaceans !

C'est parti !

alacritty

On commence par le plus évident, le terminal. Alacritty est un terminal moderne qui se veut très simple dans le sens où il ne va pas gérer les onglets et le split de fenêtres (on utilisera autre chose pour ça juste après). Il tourne sous OpenGL et bénéficie donc de la performance de ta carte graphique. Il supporte les couleurs, les polices et Wayland. Il a également un mode Vi et est hautement configurable via un fichier TOML.

zellij

Adieu tmux et bonjour Zellij ! C'est un gestionnaire de fenêtres pour terminal qui fonctionne parfaitement avec Alacritty. C'est tout comme tmux, mais en mieux. Il peut gérer les onglets, le split des fenêtres et les sessions. Tu pourras également l'étendre grâce à un système de plugins.

starship

Maintenant qu'on a notre terminal et notre gestionnaire de fenêtres, il te faut un joli prompt. Starship est là pour ça ! La configuration par défaut est vraiment top, et si tu ne veux pas te prendre la tête, tu peux la conserver telle quelle. Tu auras directement les informations de tes branches git, des versions des langages du projet sur lequel tu travailles, et bien d'autres choses.

atuin

Atuin se charge de gérer l'historique de ton shell. Tu pourras synchroniser ton historique de manière encryptée entre plusieurs machines. Ton historique sera donc accessible de partout ! Il sera stocké dans une base de données SQLite, ce qui te permettra d'effectuer des recherches avancées et rapides.

zoxide

On va commencer par remplacer les outils GNU classiques. Zoxide va remplacer ta commande cd. Il te permettra de te déplacer dans tes dossiers en fonction de leur fréquence d'utilisation. Donc, imaginons que tu as un projet dans un répertoire /home/morgan/dev/emploi-du-temps et que tu y vas souvent, il te suffira de faire un z emploi pour y accéder depuis n'importe où. Une fois adopté, tu pourras même te créer un alias cd pour z.

ripgrep

Cette fois-ci, on va remplacer grep par ripgrep. C'est un outil vraiment puissant qui te permet de chercher dans tes fichiers de manière récursive très rapidement. Franchement, la première fois que je l'ai lancé, j'ai été vraiment surpris. Une recherche dans beaucoup de dossiers a quasiment été instantanée.

eza

Eza quant à lui, va remplacer ton ls. Comme pour Zoxide, tu pourras te créer un alias ls pour eza. L'affichage te fournira une jolie coloration syntaxique en fonction des types de fichiers.

bat

Pour remplacer cat, on va utiliser bat, qui, comme pour Eza, va te fournir une coloration syntaxique de tes fichiers.

fd

La commande find n'est franchement pas la plus simple à utiliser. fd se veut beaucoup plus user-friendly. L'exécution de la recherche est réalisée de manière parallèle, donc c'est très rapide. Tu auras également les couleurs pour faciliter l'affichage.

---

Et voilà, on a fait le tour ! N'hésite pas à commenter si tu en connais d'autres, ça me permettra d'agrandir ma besace !

Nix : Package manager et gestionnaire de configuration

2024-10-12T00:00:00+02:00

Bon, c'est parti pour un article pas du tout prévu, mais c'est tellement un banger que je me dois d'en parler.

Je viens de découvrir le package manager Nix, et quelle claque !

À une époque, j'avais jeté un œil à GNU Guix et à son langage Guile, qui semblaient intéressants. Mais j'ai laissé tomber car la doc était imbuvable et ça ne semblait pas encore au point.

Puis j'ai appris récemment que Guix venait en fait de Nix et que, pour le coup, Nix était à nouveau en vogue à cause de NixOS. Un collègue m'a poussé à creuser et je n'ai pas été déçu.

Pour faire simple, Nix est un gestionnaire de paquets qui peut s'installer sur n'importe quelle distro et permet d'installer des paquets récents indépendamment de la distro. Tu peux donc rester sur Debian stable et utiliser la dernière version de Neovim grâce à Nix, par exemple.

Tout est géré dans un répertoire indépendant, /nix, et son fonctionnement peut faire penser à Git dans le sens où tout est versionné. Tu peux donc faire des rollbacks si l'installation d'un paquet s'est mal passée.

Nix

Pour commencer, tu peux installer Nix sur ta machine avec la commande suivante :

sh <(curl -L https://nixos.org/nix/install) --daemon
nix --version

On va y aller étape par étape en prenant des cas d'usage intéressants en allant du plus simple au plus compliqué.

Pour tester que tout marche bien, on va commencer par utiliser un environnement shell de nix pour installer et utiliser des paquets.

nix-shell -p cowsay lolcat

Après avoir exécuter cette commande, tu te retrouves dans un shell avec cowsay et lolcat d'installés. Tu peux les tester via :

[nix-shell:~]$ cowsay Hello, Nix! | lolcat

Tu devrais voir un joli Hello, Nix! en couleur. Une fois que tu quittes le shell, les paquets sont désinstallés. On est ici dans un cas d'environnement shell temporaire.

Il y a énormément de paquets disponibles, tu peux les chercher via le lien https://search.nixos.org/.

Script

Place aux cas d'usage.

Premier cas : tu veux balancer un script en prod, mais tu n'as pas les droits d'installer des paquets car tu n'es pas root. Ce genre de cas arrive très souvent en entreprise, surtout lorsque l'on est dev et pas admin sys ou devops.

Avec Nix, il y a moyen d'installer temporairement des paquets juste le temps d'exécution du script, de cette manière, dans un fichier type monscript.sh :

#!/usr/bin/env nix-shell
#! nix-shell -i bash --pure
#! nix-shell -p bash cacert curl jq python3Packages.xmljson
#! nix-shell -I nixpkgs=https://github.com/NixOS/nixpkgs/archive/2a601aafdc5605a5133a2ca506a34a3a73377247.tar.gz

curl https://github.com/NixOS/nixpkgs/releases.atom | xml2json | jq .

Tu vas utiliser ici les shebangs pour préciser les paquets nécessaires à l'exécution du script et tu pointes vers une version précise de Nix pour être sûr de pouvoir reproduire le script à l'identique, peut importe la machine sur laquelle tu l'installes.

Et voilà, la magie va opérer. Tu vas pouvoir bénéficier de curl, xml2json et jq.

Une fois le script exécuté, les paquets installés et nix seront supprimés.

C'est beaucoup plus simple que de gérer des Dockerfile !

Devenv

En parlant de Docker, tu peux utiliser la librairie Devenv pour gérer des environnements de dev avec Nix directement, en te passant de Docker Compose !

Pour l'installer, rien de plus simple.

nix-env -iA devenv -f https://github.com/NixOS/nixpkgs/tarball/nixpkgs-unstable

Voici un cas simple pour un environnement Angular dans un fichier devenv.nix :

{ pkgs, lib, config, inputs, ... }:

{
# https://devenv.sh/basics/
env.GREET = "devenv";

# https://devenv.sh/packages/
packages = [
    pkgs.git
    pkgs.nodejs_20
];

# https://devenv.sh/languages/
# languages.rust.enable = true;

# https://devenv.sh/processes/
processes.angular.exec = "npm run start";

# https://devenv.sh/services/
# services.postgres.enable = true;

# https://devenv.sh/scripts/
scripts.install-angular-cli.exec = ''
    mkdir -p ~/.npm-global
    npm config set prefix '~/.npm-global'
    export PATH=~/.npm-global/bin:$PATH
    if ! npm list -g @angular/cli | grep @angular/cli@17; then
    npm install -g @angular/cli@17
    fi
'';
scripts.build-api.exec = ''
    ./gradlew assemble
'';
scripts.install-app.exec = ''
    npm install
'';

enterShell = ''
    install-angular-cli
    build-api
    install-app
'';

# https://devenv.sh/tests/
enterTest = ''
    echo "Running tests"
    git --version | grep --color=auto "${pkgs.git.version}"
    node --version | grep --color=auto "${pkgs.nodejs_20.version}"
    ng version | grep "17"
    ./gradlew --version | grep "Gradle 7.4.2"
'';

# https://devenv.sh/pre-commit-hooks/
# pre-commit.hooks.shellcheck.enable = true;

# See full reference at https://devenv.sh/reference/options/
}

Tu peux ici gérer ta version de node, de npm et de angular et lancer des commandes d'installation et de build à l'entrée dans le shell, comme des npm install ou des ./gradlew assemble.

Il y a même une petite partie permettant de faire des tests pour être sûr que tout est bien configuré.

Tu peux ensuite lancer ton environnement avec la commande :

devenv up

Il va alors tout installer, tout builder et lancer automatiquement la commande npm run start.

Tu peux aussi faire un devenv shell pour entrer directement dans l'environnement shell.

Mais il est également possible de gérer tes services de base de données et autres, comme pour Docker Compose ! Sauf que tu n'es pas dans un container, mais dans un sous-shell directement. Tu peux voir la partie services qui est commenté dans mon fichier.

Attention, ça signifie que ce sont donc bien les fichiers de ton système que tu manipules lorsque tu lances des commandes.

Home Manager

Alors là, c'est mon préféré, la cerise sur le gâteau.

Tu vas pouvoir gérer tout ton home et en faire une description précise dans un fichier Nix pour le rendre reproductible.

Tu peux installer des paquets et gérer tes dotfiles au même endroit !

Je m'en sers ici pour installer mon terminal, VS Code, Neovim et toute la configuration qui va avec.

Commence par installer home-manager :

nix-channel --add https://github.com/nix-community/home-manager/archive/master.tar.gz home-manager
nix-channel --update
nix-shell '<home-manager>' -A install
. "$HOME/.nix-profile/etc/profile.d/hm-session-vars.sh"

Puis tu créés un fichier ~/.config/home-manager/home.nix pour y décrire toute ta configuration :

{ config, pkgs, ... }:

let
  secrets =
    if builtins.pathExists "/home/morgan/.config/home-manager/secrets.nix"
    then import /home/morgan/.config/home-manager/secrets.nix
    else { };
in
{
  nixpkgs = {
    config = {
      allowUnfree = true;
      allowUnfreePredicate = (_: true);
    };
  };

  programs.home-manager.enable = true;

  home.username = "morgan";
  home.homeDirectory = "/home/morgan";

  home.stateVersion = "24.05";

  home.packages = with pkgs; [
    devenv
    # Fonts
    fira-code
    fira-code-symbols
    (nerdfonts.override { fonts = [ "FiraCode" ]; })
    # Terminal
    guake
    tdrop
    wmctrl
    st
    atuin
    starship
    # Programming languages
    nodejs_20
    go
    python312
    pipx
    poetry
    ruff
    black
    pyright
    rustc
    rustfmt
    cargo
    rust-analyzer
    clippy
    zig
    lua
    # Tools
    httpie
    wget
    jq
    curl
    ffmpeg
    htop
    xclip
    bats
    ripgrep
    tmux
    eza
    bat
    fd
    tree
    peek
    rsync
    gh
    zip
    unzip
    unrar
    transmission
    # Network
    traceroute
    tcpdump
  ];

  home.file = { };

  home.sessionVariables = {
    # User configuration
    EDITOR = "nvim";
    LANG = "fr_FR.UTF-8";
    # Chrome
    CHROME_BIN = "/usr/bin/chromium";
    CHROME_EXECUTABLE = "/usr/bin/chromium";
    # Node.js
    NODE_OPTIONS = "--max-old-space-size=4096";
    # Rust
    RUST_SRC_PATH = "${pkgs.rust.packages.stable.rustPlatform.rustLibSrc}";
    # Jenkins
    JENKINS_URL = "${secrets.JENKINS_URL}";
    JENKINS_USER_ID = "${secrets.JENKINS_USER_ID}";
    JENKINS_API_TOKEN = "${secrets.JENKINS_API_TOKEN}";
  };

  home.sessionPath = [
    "$HOME/.local/bin"
  ];

  programs = {
    git = (import ./git.nix { inherit pkgs; });
    neovim = (import ./neovim.nix { inherit pkgs; });
    fish = (import ./fish.nix { inherit pkgs; });
    vscode = (import ./vscode.nix { inherit pkgs; });
    zoxide = {
      enable = true;
      enableFishIntegration= true;
      options = [
        "--cmd cd"
      ];
    };
    zellij = {
      enable = true;
      settings = {
        copy_command = "xclip -selection clipboard";
          paste_command = "xclip -selection clipboard -o";
        };
      };
  };

  fonts.fontconfig.enable = true;

}

Ici j'utilise nix pour installer mes paquets via home.packages, gérer mes variables d'environnement via home.sessionVariables et mes dotfiles via programs. Tu peux noter que j'utiliser une fichier /home/morgan/.config/home-manager/secrets.nix pour y mettre mes mots de passe et autres secrets.

Pour les programmes qui nécessitent une configuration spécifique, j'utilise des fichiers .nix que j'importe dans mon fichier principal :

git.nix pour gérer ton username, ton mail ou tes alias.
neovim.nix pour gérer tes plugins et ta configuration.
fish.nix qui est mon shell par défaut.
vscode.nix pour gérer tes extensions et ta configuration.

Tu peux ensuite appliquer ta configuration avec la commande :

home-manager switch

Et voilà, tu as tout ton home configuré à ta sauce, et tu peux le reproduire à l'identique sur n'importe quelle machine.

Note qu'il y a pas mal de nouveaux outils écrit en Rust que j'utilise. Ça pourra faire de futurs petits articles dessus si ça t'intéresse !

NixGL

On utilise principalement le home-manager pour gérer son terminal. Mais il est également possible de l'utiliser pour des applications qui utilise openGL. Par défaut, sans utiliser NixOS mais Debian par exemple, les applications openGL ne fonctionnent pas directement avec Nix.

Il existe alors un petit wrapper openGL appelé NixGL qui permet de faire fonctionner les applications comme alacritty par exemple.

Tu l'installes via :

nix-channel --add https://github.com/nix-community/nixGL/archive/main.tar.gz nixgl && nix-channel --update
nix-env -iA nixgl.auto.nixGLDefault

Tu utilises alors ce wrapper pour exécuter alacritty si tu l'as installé via home-manager :

nixGL alacritty

C'est un petit point gênant qui me donne envie de réellement migrer sur NixOS.

NixOS

Pour finir, la dernière étape serait de virer ma Debian et de migrer intégralement sur NixOS, la distro intégralement gérée par Nix. Pour le moment, j'ai encore certains besoins de Debian à cause de mon taf, mais dès que possible, je migrerai sûrement dessus.

Jette un œil sur la partie NixOS : the Linux distribution du site officiel.

Tu peux alors avoir l'intégralité de ton système géré par un fichier de configuration Nix, que ça soit pour les paquets, les services, la configuration réseau ou les utilisateurs.

Voilà, j'espère t'avoir donné envie de découvrir Nix ! Il y a beaucoup de choses, et le piège est de ne pas savoir par quel bout commencer ! Je te conseille vraiment de faire comme moi, étape par étape, petit à petit.

Un fois pris au jeu, tu verras, tu ne pourras plus t'en passer !

Ruff : le linter tout-en-un

2024-08-05T00:00:00+02:00

La guerre a fait rage pendant de nombreuses années concernant les linters et formatters Python.

On a d'abord eu autopep8 qui faisait le taf mais qui était plutôt limité. Puis sont arrivés en vrac Flake8, Pyflakes ou encore Pylint qui se sont battus pour devenir le meilleur linter de l'écosystème, mais en vain.

C'est alors qu'est venu Go avec son excellent linter intégré gofmt qui faisait magnifiquement le travail. Pas de configuration compliquée ici, juste une commande à taper et tout le monde obtient le même formatage. Il n'a pas fallu longtemps à la communauté Python pour copier l'idée (à raison) et sortir un équivalent, nommé Black.

Ouf, la guerre des linters est enfin finie et tout le monde a adopté black, on peut donc passer à autre chose non ?

Eh bien non !

Un petit dernier est arrivé et enfonce le clou en faisant tout comme black, mais en mieux.

Il s'appelle Ruff et se veut ultra rapide et performant car il est écrit en Rust.

L'idée ici est vraiment d'avoir l'unique outil final tout-en-un. C'est une sorte de fusion de black et de isort.

Tu peux l'installer directement en stand-alone via la commande suivante :

curl -LsSf https://astral.sh/ruff/install.sh | sh

Tu as alors à ta disposition deux commandes que tu peux exécuter.

La première va vérifier ton code et t'afficher les erreurs :

ruff check

La seconde va automatiquement formater ton code :

ruff format

Et voilà, c'est tout ! Tu peux t'arrêter ici et utiliser l'outil de base de cette manière sans te prendre la tête avec une configuration ou autres.

Tu as même une extension pour VS Code officielle si tu veux l'intégrer directement à ton éditeur.

Et si vraiment tu veux aller plus loin, tu peux configurer un hook de pre-commit ou encore une GitHub action.

Enfin, pour overrider la configuration par défaut, tu peux créer un fichier ruff.toml et l'éditer :

# Exclude a variety of commonly ignored directories.
exclude = [
    ".bzr",
    ".direnv",
    ".eggs",
    ".git",
    ".git-rewrite",
    ".hg",
    ".ipynb_checkpoints",
    ".mypy_cache",
    ".nox",
    ".pants.d",
    ".pyenv",
    ".pytest_cache",
    ".pytype",
    ".ruff_cache",
    ".svn",
    ".tox",
    ".venv",
    ".vscode",
    "__pypackages__",
    "_build",
    "buck-out",
    "build",
    "dist",
    "node_modules",
    "site-packages",
    "venv",
]

# Same as Black.
line-length = 88
indent-width = 4

# Assume Python 3.8
target-version = "py38"

[lint]
# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`) codes by default.
select = ["E4", "E7", "E9", "F"]
ignore = []

# Allow fix for all enabled rules (when `--fix`) is provided.
fixable = ["ALL"]
unfixable = []

# Allow unused variables when underscore-prefixed.
dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"

[format]
# Like Black, use double quotes for strings.
quote-style = "double"

# Like Black, indent with spaces, rather than tabs.
indent-style = "space"

# Like Black, respect magic trailing commas.
skip-magic-trailing-comma = false

# Like Black, automatically detect the appropriate line ending.
line-ending = "auto"

Mais franchement je ne le conseillerais pas, sauf raison vraiment majeure et indispensable. Autant garder la configuration par défaut pour rester dans l'idée d'origine de la simplicité de gofmt.

Happy coding !

Shuttle.rs : Déploiement d'un frontend

2024-08-01T00:00:00+02:00

Petit article rapide qui fait suite au déploiement d'un backend en Rust avec Shuttle.

Après avoir créé ton API pour ton application de TODOs avec Axum, tu vas pouvoir y ajouter un petit frontend sympa également déployé sous Shuttle pour tester tout ça.

J'hésitais entre partir sur une solution de création de frontend en Rust type Leptos ou Yew, mais ces outils feront l'objet d'articles futurs. Pour rester ultra simple, tu peux partir sur AlpineJS pour la gestion des composants JS et sur Picocss pour styliser un peu tout ça.

Tu reprends ton code Axum, et on commence par y ajouter notre page html.

Tu peux créer un fichier templates/index.html de cette manière :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>TODO App</title>
    <link rel="stylesheet" href="https://unpkg.com/@picocss/pico@1.4.0/css/pico.min.css">
    <script src="https://unpkg.com/alpinejs" defer></script>
</head>
<body>
    <main class="container" x-data="todoApp()">
        <h1>TODO App</h1>

        <form @submit.prevent="addTodo">
            <input type="text" x-model="newTodo" placeholder="Add a new todo" required>
            <button type="submit">Add</button>
        </form>

        <ul>
            <template x-for="todo in todos" :key="todo.id">
                <li>
                    <span x-text="todo.note"></span>
                    <button @click="removeTodo(todo.id)" class="secondary">Delete</button>
                </li>
            </template>
        </ul>
    </main>

    <script>
        function todoApp() {
            return {
                todos: [],
                newTodo: '',

                async fetchTodos() {
                    const response = await fetch('/todos');
                    this.todos = await response.json();
                },

                async addTodo() {
                    const response = await fetch('/todos', {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json'
                        },
                        body: JSON.stringify({ note: this.newTodo })
                    });
                    const todo = await response.json();
                    this.todos.push(todo);
                    this.newTodo = '';
                },

                async removeTodo(id) {
                    await fetch(`/todos/${id}`, {
                        method: 'DELETE'
                    });
                    this.todos = this.todos.filter(todo => todo.id !== id);
                },

                async init() {
                    await this.fetchTodos();
                }
            };
        }
    </script>
</body>
</html>

Tu as donc AlpineJS qui va se charger de lister les TODOs et de mettre à jour l'UI lorsque tu en ajoutes ou que tu en effaces. Les appels HTTP sont directement gérés avec fetch.

Picocss stylise automatiquement ton formulaire et tes boutons.

Ensuite, on va modifier le fichier src/main.rs pour que Axum expose notre index.html lors de l'appel de la racine du site.

use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::{Html, IntoResponse},
    routing::{delete, get, post},
    Json, Router,
};
use sqlx::PgPool;
use tokio::fs::read_to_string;

mod models;
use models::{Todo, TodoNew, MyState};

...

async fn serve_index() -> impl IntoResponse {
    match read_to_string("templates/index.html").await {
        Ok(html) => Html(html).into_response(),
        Err(_) => (StatusCode::INTERNAL_SERVER_ERROR, "Failed to load HTML file").into_response(),
    }
}

Et voilà ! Tu peux redéployer ton application en prod avec cargo shuttle deploy et profiter de ta petite interface graphique !

Le résultat complet est disponible sur mon dépôt github.

Shuttle.rs : Déploiement d'un backend

2024-07-28T00:00:00+02:00

Aujourd'hui, je vais te parler d'un service que je viens de découvrir et qui mérite le coup d'oeil.

Si comme moi, tu as quelques projets perso que tu veux héberger mais que tu n'as pas forcément envie de débourser un abonnement pour un hébergeur, tu es au bon endroit.

Pour héberger du front-end, c'est facile. On a au choix Netlify ou Vercel qui font très bien l'affaire.

Mais si c'est pour un back-end avec une base de données, c'est tout de suite une autre affaire si tu ne veux pas utiliser de méthode serverless.

Jusqu'à présent, j'utilisais Pythonanywhere qui est vraiment un super service pour déployer du Python, et de temps en temps Render, mais qui a de grosses latences pour son service gratuit.

En cherchant une solution pour héberger du Rust, je suis alors tombé sur Shuttle. Shuttle se veut être le Vercel du backend en gros.

Non seulement la version Community de l'outil est gratuite, mais elle permet d'avoir directement une base de données Postgres et n'a pas de grosses limitations de performances comme chez Render.

De plus, le mot d'ordre de l'outil se veut la simplicité. Exit la complexité de déploiement d'une application. Pour ce faire, il utilise une méthode d'intégration de l'infrastructure dans le code.

Alors certes, ça peut poser polémique dans le sens où le code source est alors fortement lié au service d'hébergement. Mais dans le cas de Shuttle, le lien entre code et infra se fait avec de simples annotations facilement remplaçables dans le cadre d'une migration.

Ici, pas besoin de fichier de configuration pour Postgres ou Nginx, tout est automatiquement géré par le service.

Installation

L'installation de l'environnement de Shuttle se fait directement avec Cargo. Après t'être connecté au site et avoir récupéré ta clé d'API, il te suffit d'exécuter les 3 commandes suivantes pour avoir un hello-world déployé en Rust.

cargo install cargo-shuttle
cargo shuttle init --create-env
cargo shuttle deploy

Tu peux alors choisir ton framework Rust préféré via le prompt, ici on va partir sur Axum.

Ultra simple !

Todos

On va passer à un exemple un peu plus poussé avec une API pour une gestion d'une TODO list avec une base de données Postgres.

Cargo.toml

À partir du hello-world de base, on va ajouter la prise en charge de Postgres et de Sqlx dans Shuttle via le package shuttle-shared-db.

[package]
name = "mon-app"
version = "0.1.0"
edition = "2021"

[dependencies]
axum = "0.7.3"
serde = { version = "1.0.188", features = ["derive"] }
shuttle-axum = "0.47.0"
shuttle-runtime = "0.47.0"
shuttle-shared-db = { version = "0.47.0", features = ["postgres", "sqlx"] }
sqlx = "0.7.1"
tokio = "1.28.2"

migrations/0001_init.sql

On ajoute également un script de migration pour créer notre table dans la base de données :

CREATE TABLE IF NOT EXISTS todos (
    id serial PRIMARY KEY,
    note TEXT NOT NULL
);

src/models.rs

Tu peux désormais créer tes structures pour gérer ta table de Todo. Todo correspond à l'objet de notre table, TodoNew sera utilisé pour la création d'un nouvel item et MyState est utilisé pour gérer le pool Postgres.

use serde::{Deserialize, Serialize};
use sqlx::{FromRow, PgPool};

#[derive(Deserialize)]
pub struct TodoNew {
    pub note: String,
}

#[derive(Serialize, FromRow)]
pub struct Todo {
    pub id: i32,
    pub note: String,
}

#[derive(Clone)]
pub struct MyState {
    pub pool: PgPool,
}

src/main.rs

Place à notre API.

Tu remarqueras que l'intégration avec Shuttle se fait simplement via les annotations #[shuttle_runtime::main] pour déclarer notre application principale, #[shuttle_shared_db::Postgres] pool: PgPool pour la connexion à notre base de données Postgresql et shuttle_axum::ShuttleAxum pour indiquer qu'on utilise le framework Axum.

#[shuttle_runtime::main]
async fn main(#[shuttle_shared_db::Postgres] pool: PgPool) -> shuttle_axum::ShuttleAxum {
...
}

Tu vois, quand je te disais que l'intégration à l'infrastructure était ultra simple !

Et voilà, on passe enfin sur l'écriture de nos routes. On va pouvoir ajouter, lire, lister et supprimer nos TODOs.

use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::IntoResponse,
    routing::{delete, get, post},
    Json, Router,
};
use sqlx::PgPool;

mod models;
use models::{Todo, TodoNew, MyState};

// Add a function to retrieve all todos
async fn retrieve_all(
    State(state): State<MyState>,
) -> Result<impl IntoResponse, impl IntoResponse> {
    match sqlx::query_as::<_, Todo>("SELECT * FROM todos")
        .fetch_all(&state.pool)
        .await
    {
        Ok(todos) => Ok((StatusCode::OK, Json(todos))),
        Err(e) => Err((StatusCode::BAD_REQUEST, e.to_string())),
    }
}

async fn retrieve(
    Path(id): Path<i32>,
    State(state): State<MyState>,
) -> Result<impl IntoResponse, impl IntoResponse> {
    match sqlx::query_as::<_, Todo>("SELECT * FROM todos WHERE id = $1")
        .bind(id)
        .fetch_one(&state.pool)
        .await
    {
        Ok(todo) => Ok((StatusCode::OK, Json(todo))),
        Err(e) => Err((StatusCode::BAD_REQUEST, e.to_string())),
    }
}

async fn add(
    State(state): State<MyState>,
    Json(data): Json<TodoNew>,
) -> Result<impl IntoResponse, impl IntoResponse> {
    match sqlx::query_as::<_, Todo>("INSERT INTO todos (note) VALUES ($1) RETURNING id, note")
        .bind(&data.note)
        .fetch_one(&state.pool)
        .await
    {
        Ok(todo) => Ok((StatusCode::CREATED, Json(todo))),
        Err(e) => Err((StatusCode::BAD_REQUEST, e.to_string())),
    }
}

// function to remove a todo
async fn remove(
    Path(id): Path<i32>,
    State(state): State<MyState>,
) -> Result<impl IntoResponse, impl IntoResponse> {
    match sqlx::query("DELETE FROM todos WHERE id = $1")
        .bind(id)
        .execute(&state.pool)
        .await
    {
        Ok(_) => Ok(StatusCode::NO_CONTENT),
        Err(e) => Err((StatusCode::BAD_REQUEST, e.to_string())),
    }
}


#[shuttle_runtime::main]
async fn main(#[shuttle_shared_db::Postgres] pool: PgPool) -> shuttle_axum::ShuttleAxum {
    sqlx::migrate!()
        .run(&pool)
        .await
        .expect("Failed to run migrations");

    let state = MyState { pool };
    let router = Router::new()
        .route("/todos", get(retrieve_all))
        .route("/todos", post(add))
        .route("/todos/:id", get(retrieve))
        .route("/todos/:id", delete(remove))
        .with_state(state);

    Ok(router.into())
}

Tu relances alors ta commande cargo shuttle deploy pour avoir ton service en ligne !

Et si tu veux d'abord tester localement, tu lances cargo shuttle run et tu peux tester ton service avec curl directement :

curl -X POST -H 'content-type: application/json' localhost:8000/todos --data '{"note":"My todo"}'
# {"id":1,"note":"My todo"}

curl localhost:8000/todos/1
# {"id":1,"note":"My todo"}

curl localhost:8000/todos
# [{"id":1,"note":"My todo"}]

curl -X DELETE localhost:8000/todos/1
# []

Tu peux alors appeler ton backend Shuttle depuis ton frontend hébergé sur Netlify ou Vercel sans aucun problème.

Découverte du language Roc

2024-07-15T00:00:00+02:00

Programmation fonctionnelle

Ah, la programmation fonctionnelle !

Je me rappellerai toujours ma découverte de Haskell avec l'excellent livre Learn You a Haskell que je conseille à tout le monde de lire ! Les concepts derrière le langage ont été pour moi complètement mind blowing et je garde toujours dans un coin de tête l'idée d'immutabilité et de fonction pure quand je code.

Puis, est venu Elm qui a fait l'effet d'une bombe dans le monde du développement front-end. Alors évidemment, pas une bombe dans le sens où tout le monde l'a adopté, car il est finalement resté de niche. Mais il faut savoir que tous les fondamentaux derrière Redux et l'idée d'un store viennent directement d'Elm. Sans le savoir, la plupart des concepts qui sont dans ton framework préféré viennent d'Elm.

Alors quand j'ai vu que Richard Feldman, l'auteur de Elm in Action et l'un des plus gros contributeurs de la communauté Elm, se lance dans l'écriture de son langage, ça m'a forcément intrigué.

Roc lang

Roc se veut donc une sorte d'héritier d'Elm, mais ici on parle d'un langage backend et pas uniquement dédié au frontend.

Là où Elm et Haskell ont échoué, c'est-à-dire à être adoptés massivement, Roc essaye de mélanger programmation fonctionnelle et simplicité de gestion des effets de bord potentiels.

Il se veut être aussi simple à utiliser qu'un langage impératif pour la gestion des I/O et ça fait du bien.

Performance

On reproche souvent les mauvaises performances d'un langage fonctionnel. Ici, le compilateur et le tooling sont écrits intégralement en Rust, avec des bouts de Zig qui font leur apparition.

On est donc ici dans un langage qui peut compiler en code machine ou en WebAssembly comme Rust.

Installation

Au niveau de l'installation, il n'y a pas encore vraiment de packaging car le langage est tout récent. Donc on dézippe le tar.gz, on le met dans le path et on teste le REPL :

sudo apt install libc-dev binutils
wget https://github.com/roc-lang/roc/releases/download/nightly/roc_nightly-linux_x86_64-latest.tar.gz
tar -xf roc_nightly-linux_x86_64-latest.tar.gz
export PATH=$PATH:~/path/to/roc_nightly-linux_x86_64-<VERSION>
roc version
roc repl

Au final le langage ressemble à ça :

birds = 3
iguanas = 2
total = addAndStringify birds iguanas

main =
    Stdout.line! "There are $(total) animals."

addAndStringify = \num1, num2 ->
    Num.toStr (num1 + num2)

Tu noteras qu'on n'a pas besoin d'utiliser les parenthèses pour faire des appels de fonctions.

Ici l'utilisation d'un map :

List.map [1, 2, 3] \num -> num * 2

Je ne vais pas passer en revue tout le langage, pour ça tu peux lire le tutoriel. Mais on va voir les 2 ou 3 points intéressants.

Typage

Au niveau du typage, on est dans le typage statique que l'on peut décrire au-dessus de notre fonction via des annotations, comme pour Elm et Haskell. En vrac les exemples sortis du tutoriel :

fullName : Str, Str -> Str
fullName = \firstName, lastName ->
    "$(firstName) $(lastName)"

Musician : { firstName : Str, lastName : Str }

amy : Musician
amy = { firstName: "Amy", lastName: "Lee" }

simone : Musician
simone = { firstName: "Simone", lastName: "Simons" }

names : List Str
names = ["Amy", "Simone", "Tarja"]

isEmpty : List * -> Bool

Mais sache que c'est optionnel car le langage intègre l'inférence de type, ce qui assouplit l'utilisation du langage. Ce qui veut dire que l'écriture suivante est valide :

fullName = \firstName, lastName ->
    "$(firstName) $(lastName)"

Pattern matching

On peut faire du pattern matching sur des listes de manière très simple, ce qui est quand même super cool :

when myList is
    [] -> 0 # the list is empty
    [Foo, ..] -> 1 # it starts with a Foo tag
    [_, ..] -> 2 # it contains at least one element, which we ignore
    [Foo, Bar, ..] -> 3 # it starts with a Foo tag followed by a Bar tag
    [Foo, Bar, Baz] -> 4 # it has exactly 3 elements: Foo, Bar, and Baz
    [Foo, a, ..] -> 5 # its first element is Foo, and its second we name `a`
    [Ok a, ..] -> 6 # it starts with an Ok containing a payload named `a`
    [.., Foo] -> 7 # it ends with a Foo tag
    [A, B, .., C, D] -> 8 # it has certain elements at the beginning and end
    [head, .. as tail] -> 9 # destructure a list into a first element (head) and the rest (tail)

Pipe operator

On a l'opérateur pipe pour enchaîner les fonctions :

["a", "b", "c"]
|> List.reverse
|> List.append "d"

Tous les langages modernes devraient intégrer cet opérateur, c'est tellement plus lisible !

Debugger

Petit debugger intégré avec le mot-clé dbg qui permet de debugger facilement hors IDE à la manière d'un print avec des infos en plus :

pluralize = \singular, plural, count ->
    dbg count

    if count == 1 then
        singular
    else
        plural

Gestion des erreurs

Ici on a une gestion des erreurs qui va rappeler Rust, en utilisant les mots-clés Ok et Err :

answer : Str
answer =
    when Str.fromUtf8 definitelyValidUtf8 is
        Ok str -> str
        Err _ -> crash "This should never happen!"

Testing

Bien évidemment, comme tout langage qui se respecte, on peut écrire des tests unitaires avec le mot-clé expect :

pluralize = \singular, plural, count ->
    countStr = Num.toStr count

    if count == 1 then
        "$(countStr) $(singular)"
    else
        "$(countStr) $(plural)"

    expect pluralize "cactus" "cacti" 1 == "1 cactus"
    expect pluralize "cactus" "cacti" 2 == "2 cacti"

Tasks

Bon, cette dernière partie est l'une des plus intéressantes. Je te parlais au début de l'article de la gestion simplifiée des I/O et des effets de bord. Ici, pas de Monad, mais un système de Task. Chaque plateforme implémente ses propres Tasks, ce qui permettra à terme de gérer les bases de données, les appels réseaux, les appels asynchrones (via le suffixe !) ou encore les fichiers de la même manière.

Ici un exemple un peu plus avancé de gestion de JSON :

app [main] {
    cli: platform "https://github.com/roc-lang/basic-cli/releases/download/0.10.0/vNe6s9hWzoTZtFmNkvEICPErI9ptji_ySjicO6CkucY.tar.br",
    json: "https://github.com/lukewilliamboswell/roc-json/releases/download/0.8.0/BlWJJh_ouV7c_IwvecYpgpR3jOCzVO-oyk-7ISdl2S4.tar.br",
}

import cli.Stdout
import cli.Task
import json.Core exposing [jsonWithOptions]
import Decode exposing [fromBytesPartial]

main =
    requestBody = Str.toUtf8 "{\"Image\":{\"Animated\":false,\"Height\":600,\"Ids\":[116,943,234,38793],\"Thumbnail\":{\"Height\":125,\"Url\":\"http:\\/\\/www.example.com\\/image\\/481989943\",\"Width\":100},\"Title\":\"View from 15th Floor\",\"Width\":800}}"

    decoder = jsonWithOptions { fieldNameMapping: PascalCase }

    decoded : DecodeResult ImageRequest
    decoded = fromBytesPartial requestBody decoder

    when decoded.result is
        Ok record -> Stdout.line "Successfully decoded image, title:\"$(record.image.title)\""
        Err _ -> Task.err (Exit 1 "Error, failed to decode image")

ImageRequest : {
    image : {
        width : I64,
        height : I64,
        title : Str,
        thumbnail : {
            url : Str,
            height : F32,
            width : F32,
        },
        animated : Bool,
        ids : List U32,
    },
}

Et voilà pour cette introduction à Roc, j'espère t'avoir au moins intrigué !

Pour avoir une liste d'exemples plus avancés, tu peux jeter un oeil ici.

Et si tu viens du monde de Elm, il y a même un guide roc for elm programmers !

L'éditeur Zed

2024-07-14T00:00:00+02:00

Petit article rapide pour t'annoncer que ça y est ! L'éditeur Zed est enfin disponible sous Linux après avoir été pendant plusieurs mois uniquement réservé aux utilisateurs de Mac.

Pour l'installer, rien de plus simple :

curl https://zed.dev/install.sh | sh

Zed se veut être un éditeur de texte de dernière génération qui regroupe le meilleur des mondes des éditeurs. Il se veut très performant, collaboratif et open source.

La team qui se cache derrière ce produit n'est autre que les anciens développeurs de l'éditeur Atom. Ils sont de retour et prennent leur revanche sur VS Code qui les avait grassement copiés.

Performance

Au niveau des performances, il se veut être le plus rapide sur le marché actuellement. Pour arriver à ce niveau, il utilise la puissance du GPU, comme s'il s'agissait d'un jeu vidéo.

Le langage de programmation derrière n'est autre que Rust, ce qui lui garantit une bonne gestion de la mémoire et une certaine rapidité d'exécution.

Intelligence artificielle

L'un des points majeurs de cet éditeur est l'intégration aux petits oignons de Github Copilot. La complétion de l'outil est au final une des meilleures qu'il m'a été donné de tester.

Il intègre également GPT-4 pour refactorer le code et utiliser le prompt directement dans l'éditeur.

Collaboratif

L'éditeur est également très axé sur le travail à plusieurs. Il est possible de discuter via des canaux, de modifier du code ensemble, de partager des notes et autres.

Autres fonctionnalités

Enfin, la majorité des langages sont supportés par défaut et git est très bien intégré. Il possède un terminal interne comme VS Code et un mode Vim intégré.

Petit à petit, des extensions font leur apparition et je pense qu'il a toutes ses chances pour devenir l'un des éditeurs les plus populaires du marché.

Pour ma part, j'ai déjà switché de VS Code à Zed pour Python, Rust et Typescript.

À tester !

Arrêtons avec Agile SAFe Scrum !

2024-07-12T00:00:00+02:00

À mon tour d'ajouter ma pierre à l'édifice des articles à charge sur Agile ! Je tiens à préciser que c'est mon ressenti personnel au bout de plusieurs années de travail avec cette méthode dans le monde de l'entreprise et non une vérité absolue.

Make programming fun again

La programmation, à la base, c'est fun. Et c'est bien pour ça qu'on a été attiré par ce métier. On pourrait penser qu'il s'agit d'un métier de production. Pisser du code, comme on dit. Mais en réalité, pour les passionnés, il s'agit d'un métier artistique. Oui, le code est une forme d'art, au même titre que la peinture, l'écriture ou la musique. Il nécessite de la créativité et le développeur y met toute son âme et sa personnalité.

Le processus est très similaire à celui d'un musicien qui compose un morceau de musique. Le développeur a besoin de toute sa liberté pour exprimer son art. À lui de faire ses choix de langages et de frameworks, d'organiser son code comme il l'entend. Il a le droit de se tromper, de recommencer pour faire mieux et de ne pas atteindre la perfection.

La méthode Agile SAFe Scrum et ses processus réduisent à néant cette créativité et se concentrent uniquement sur la partie production.

On devient alors le développeur n°3 de l'équipe 2 qui travaille sur la tâche Jira 34762 dans le sprint 34 de l'épique 5678 pour la release 26. À terme, on se transforme en robot prêt à faire un burn-out à tout moment.

Des pratiques sectaires

Franchement, cette méthode a tous les codes d'une secte. On va en parcourir ensemble en vrac :

les réunions sont carrément appelées cérémonies ou rituels, dois-je en rajouter ?
les Scrum Masters et coachs Agile sont l'équivalent des prêtres et évêques qui prêchent la bonne parole.
les rétrospectives sont une sorte de confessionnal où on y absout les péchés.
aller au PI planning, c'est comme faire un pèlerinage pour assister à la grande messe.
il a sa bible, le manifeste Agile, son propre langage et ses adeptes.

Tout y est.

Mais le pire de tout, c'est qu'on y retrouve même la notion de blasphème. Quiconque dans une équipe se mettrait à critiquer ouvertement la méthodologie du projet peut s'en faire exclure.

Vraiment flippant.

Infantilisation

Tous ces rituels ont tendance à infantiliser les développeurs et à réduire leur autonomie.

Abordons rapidement l'horreur des daily meetings. On se croirait à l'école primaire où on doit montrer qu'on a bien travaillé la veille.

Non mais t'as pas compris, c'est pour organiser la journée.

Ouais ok, mais vous croyez pas que les membres d'une équipe se parlent naturellement au cours de la journée au besoin ? Vous croyez qu'on attend le daily du lendemain avant de se dire les choses s'il y a un problème ?

Une équipe qui fonctionne se parle au quotidien et n'a pas besoin de ce genre de réunions. Laissez les développeurs se débrouiller entre eux !

Et je n'aborde même pas les jeux agiles à base de construction de tours Kapla et autres. Ça serait trop facile.

Les specs

Les specs changent tout le temps et il faut s'y adapter. C'est ça être Agile !

Alors ok, les specs peuvent changer. Mais franchement, si on avait pris le temps de rédiger un vrai cahier des charges comme dans le temps, avec validation du client, tu ne penses pas que ça aurait limité la casse et amélioré la compréhension et les besoins du projet ?

Avec ce système d'itérations et de sprints, on perd toute vue d'ensemble et de vision globale sur le long terme.

Rendez-moi mon cahier des charges !

La réunionite

Des réunions, des réunions, des réunions.

Bon, je ne voulais pas spécialement m'éterniser sur ce sujet mais je suis obligé d'en parler à minima. Il y a énormément de temps perdu de ce côté-là. Faire des réunions avec les clients pour définir les besoins, ok. Mais pour le reste ? Poubelle.

Une fois que tu auras atteint le stade de faire une réunion pour préparer une autre réunion, le combat est perdu. On atteint parfois limite le stade de Inception avec le concept de réunion dans la réunion dans la réunion.

Que dire de plus ?

Ton âme est aspirée petit à petit dans le néant et est vidée de toute énergie vitale.

Courage.

Ah ! Et arrêtez de vous plaindre que les développements prennent du retard si on est en réunion la moitié du temps !

Le chiffrage

Alors là, on est dans le domaine de la grosse blague.

Le chiffrage en complexité, ça ne marche pas. C'est toujours faux et complètement bancal. Et intérieurement, tout est quand même converti en jour-homme.

Quelle perte de temps.

La priorisation des tâches dans le Kanban est la seule nécessité.

Et Jira ... mon dieu je crois qu'au bout d'un moment tout le monde déteste cette appli, c'est inévitable.

Les juniors

Alors ce point, je le trouve assez terrible, car ça représente le futur de notre métier. Et ça m'attriste vraiment pour la nouvelle génération de développeurs qui arrivent.

Tous les juniors qui sortent de l'école ne connaissent plus que la méthode Agile, désormais enseignée en classe. Ils n'envisagent même pas qu'il a existé un monde sans, et limite certains n'arrivent même plus à penser en dehors de ce cadre.

Bientôt, tout sera gangrené par cette méthode et on ne pourra plus en sortir. Petit à petit, tout ne sera plus que Agile Scrum.

Les 3/4 des offres d'emploi disponibles sur le marché mentionnent systématiquement Agile Scrum. Trouver un poste qui ne la mentionne pas devient un véritable parcours du combattant.

Du bon ?

Bien évidemment, tout Agile n'est pas à jeter. C'est pourquoi je m'attaque spécifiquement à SAFe Scrum.

À l'origine, le manifeste partait d'une bonne intention, qui était de redonner le pouvoir aux développeurs face à la hiérarchie. Mais malheureusement, dans les faits, le monde de l'entreprise se l'est approprié, a gardé les éléments qui l'arrangeaient et ça s'est retourné contre nous.

Je t'invite à regarder ce qui se dit dans le manifeste du Software Craftsmanship qui redéfinit certains concepts Agile de manière plus saine :

Pas seulement des logiciels opérationnels, mais aussi des logiciels bien conçus.
Pas seulement l'adaptation aux changements, mais aussi l'ajout constant de la valeur.
Pas seulement les individus et leurs interactions, mais aussi une communauté de professionnels.
Pas seulement la collaboration avec les clients, mais aussi des partenariats productifs.

Et XP dans tout ça ?

On va quand même garder certains concepts de Extreme Programming, comme le focus sur les tests unitaires, l'intégration continue, la qualité du code via la revue de merge requests et éventuellement le Test Driven Development.

Enfin, personnellement, le pair programming, c'est pas trop mon délire, mais je n'ai rien contre.

Mais Scrum et SAFe donc ?

Non, ça dégage.

Que faire ?

Si vous êtes dans une boîte complètement sectaire, il n'y a malheureusement rien à faire à part partir. La perte du fun, l'enchaînement des sprints et la réunionite aiguë vont te mener au burn-out.

Ok mais tu préconises quoi alors ?

Lire et se faire sa propre interprétation du manifeste Agile.
Oublier intégralement Scrum et SAFe.
S'approprier les concepts de XP et Software Craftsmanship.
Rédiger un cahier des charges avec le client.
Discuter en direct avec le client.
Parler au quotidien avec ton équipe au besoin.
Garder ta créativité, ton énergie, ta passion et ne deviens pas juste un numéro.
Choisir les outils et langages selon les besoins. Un bon artisan a sa propre caisse à outils.
Éviter la réunionite au maximum. Quelques réunions de conception en petit comité suffisent largement.
Rejoindre une secte, ça finit toujours mal. Dans les cas extrêmes, pars.

Gardons espoir que les mauvaises pratiques de Agile partiront avec le temps et que le monde de l'entreprise passera à autre chose !

Domain Driven Design en Rust

2022-12-04T00:00:00+01:00

Domain Driven Design, quésaco ?

Le Domain Driven Design, communément appelé DDD, est un paradigme de développement qui met l'accent sur la compréhension approfondie du domaine dans lequel ton application sera utilisée.

Tu peux donc imaginer des modèles de données et des algorithmes qui reflètent précisément les concepts et les relations qui existent dans ton domaine d'application.

Cela te permet, en théorie, de créer des logiciels plus clairs et plus faciles à comprendre pour les personnes du projet non techniques.

L'accent est alors mis sur la collaboration avec les experts du domaine pour obtenir leur avis et leur feedback, et permet donc de parler le même langage.

DDD en Rust

Tu dois d'abord comprendre toute la partie métier de ton appli pour pouvoir définir le domaine. Cette phase d'analyse et de compréhension est la plus importante et peut t'aider à résoudre les problèmes de manière plus efficace pour maintenir et faire évoluer ton application.

Ensuite, tu peux utiliser des structures en Rust pour représenter les concepts du domaine, ainsi que des fonctions pour manipuler ces structures.

Exemple d'application de gestion de compte bancaire.

Voici un exemple de code en Rust qui utilise le DDD pour gérer un compte bancaire :

use chrono::{DateTime, Utc};

struct Account {
    balance: u64,
    transactions: Vec<Transaction>,
}

struct Transaction {
    amount: u64,
    date: DateTime<Utc>,
}

struct Client {
    name: String,
    accounts: Vec<Account>,
}

impl Account {
    fn deposit(&mut self, amount: u64) {
        self.balance += amount;
        self.transactions.push(Transaction {
            amount,
            date: Utc::now(),
        });
    }

    fn withdraw(&mut self, amount: u64) -> Result<(), &'static str> {
        if self.balance >= amount {
            self.balance -= amount;
            self.transactions.push(Transaction {
                amount,
                date: Utc::now(),
            });
            Ok(())
        } else {
            Err("Insufficient funds")
        }
    }
}

fn main() {
    let mut client = Client {
        name: "John Doe".to_string(),
        accounts: vec![Account {
            balance: 0,
            transactions: vec![],
        }],
    };

    client.accounts[0].deposit(100);
    client.accounts[0].withdraw(50).unwrap();
    client.accounts[0].withdraw(50).unwrap();
}

Ce code utilise des structures pour représenter les concepts du domaine (compte bancaire, transaction et client), ainsi que des fonctions pour manipuler ces structures (dépôt, retrait, etc.).

Exemple plus avancé : un système de gestion de stock.

Voici un exemple de code Rust plus avancé qui utilise le DDD pour gérer un système de gestion de stock :

use chrono::{DateTime, Utc};
use std::collections::HashMap;

// Représente un produit dans le stock
#[derive(Clone, Debug)]
struct Product {
    // Nom du produit
    name: String,
    // Quantité en stock
    quantity: u32,
    // Prix de vente
    price: f32,
}

// Représente un client dans le système
#[derive(Clone, Debug)]
struct Customer {
    // Nom du client
    name: String,
    // Adresse email du client
    email: String,
}

// Représente une commande dans le système
#[derive(Clone, Debug)]
struct Order {
    // Identifiant unique de la commande
    id: u32,
    // Produits commandés
    products: Vec<Product>,
    // Client qui a passé la commande
    customer: Customer,
    // Date de la commande
    date: DateTime<Utc>,
}

// Représente un système de gestion de stock
#[derive(Debug)]
struct StockSystem {
    // Produits en stock
    products: HashMap<String, Product>,
    // Clients enregistrés dans le système
    customers: HashMap<String, Customer>,
    // Commandes enregistrées dans le système
    orders: Vec<Order>,
}

impl StockSystem {
    // Ajoute un produit au stock
    fn add_product(&mut self, product: Product) {
        self.products.insert(product.name.clone(), product);
    }

    // Ajoute un client au système
    fn add_customer(&mut self, customer: Customer) {
        self.customers.insert(customer.email.clone(), customer);
    }

    // Passe une commande pour un client donné
    fn place_order(&mut self, products: Vec<Product>, customer_email: &str) -> Result<Order, &'static str> {
        // Vérifie si les produits demandés sont en stock
        for product in &products {
            let stock_product = self.products.get(&product.name);
            if stock_product.is_none() || stock_product.unwrap().quantity < product.quantity {
                return Err("Product out of stock");
            }
        }

        // Vérifie si le client existe dans le système
        let customer = self.customers.get(customer_email);
        if customer.is_none() {
            return Err("Customer not found");
        } else {
            // Réduit la quantité en stock pour les produits commandés
            for product in &products {
                let mut stock_product = self.products.get_mut(&product.name).unwrap();
                stock_product.quantity -= product.quantity;
            }

            // Crée la commande
            let order = Order {
                id: self.orders.len() as u32 + 1,
                products,
                customer: customer.unwrap().clone(),
                date: Utc::now(),
            };

            // Ajoute la commande au système
            self.orders.push(order.clone());

            Ok(order)
        }
    }
}

Pour utiliser ce code, tu peux créer une instance de la structure StockSystem et ajouter des produits, des clients et passer des commandes :

fn main() {
    // Crée une instance du système de stock
    let mut stock_system = StockSystem {
        products: HashMap::new(),
        customers: HashMap::new(),
        orders: Vec::new(),
    };

    // Ajoute des produits au stock
    stock_system.add_product(Product {
        name: "Table".to_string(),
        quantity: 10,
        price: 100.0,
    });
    stock_system.add_product(Product {
        name: "Chair".to_string(),
        quantity: 20,
        price: 50.0,
    });

    // Ajoute des clients au système
    stock_system.add_customer(Customer {
        name: "John Doe".to_string(),
        email: "john.doe@example.com".to_string(),
    });
    stock_system.add_customer(Customer {
        name: "Jane Doe".to_string(),
        email: "jane.doe@example.com".to_string(),
    });


    // Passe une commande pour un client
    let order = stock_system.place_order(vec![
        Product {
            name: "Table".to_string(),
            quantity: 1,
            price: 100.0,
        },
        Product {
            name: "Chair".to_string(),
            quantity: 2,
            price: 50.0,
        },
    ], "jane.doe@example.com").unwrap();

    println!("Order placed: {:?}", order);

    // Affiche les informations du système
    println!("Stock system: {:?}", stock_system);
}

Avantages et défis

En utilisant le DDD dans tes projets, tu peux bénéficier de nombreux avantages, tels que :

Des logiciels plus clairs et plus faciles à comprendre, ce qui peut améliorer la collaboration avec les autres développeurs et les experts du domaine.
Des modèles de données et des algorithmes qui reflètent les concepts et les relations du domaine d'application, ce qui peut améliorer la qualité de ton code et la précision de tes résultats.
Un code plus facile à maintenir et à évoluer, ce qui peut réduire les coûts de développement et accélérer les délais de mise sur le marché.

Cependant, le DDD peut également présenter des défis, tels que :

La nécessité de comprendre en profondeur le domaine d'application, ce qui peut être difficile et prendre du temps pour les développeurs qui ne sont pas des experts du domaine.
L'intégration du DDD dans un projet existant peut être complexe et perturbante pour le fonctionnement de l'application.
La mise en place d'un processus de développement orienté domaine peut nécessiter des changements importants dans la façon dont les équipes de développement travaillent, ce qui peut être difficile à gérer.

Smart Contract Elrond en Rust : Multiple NFTs staking

2022-10-16T00:00:00+02:00

C'est parti pour un petit article faisant suite au premier dédié au staking de NFT sur Elrond.

Contexte

Afin d'avoir un premier jet fonctionnel, on a vu comment staker un NFT sur un smart contract avec quelques limitations :

Chaque utilisateur représenté par une adresse Elrond ne peut envoyer qu'un seul NFT dans la pool.
Les récompenses sont à réclamer régulièrement et ne sont pas directement attribuées.
Une seule collection de NFT est supportée. Donc pour faire une pool de staking sur une autre collection, il faudra déployer un deuxième SC.

On va ici voir comment faire sauter la première limitation, c'est-à-dire de permettre le staking de plusieurs NFTs par adresse Elrond dans la pool.

Dans ta dapp, tu pourras ainsi faire quelque-chose comme ça :

Smart Contract

On reprend donc le code du smart contract précédent, et on va ajouter une nouvelle fonctionnalité : le staking de plusieurs NFTs.

Tu commences donc par modifier le fichier src/stake_info.rs de la manière suivante :

elrond_wasm::imports!();
elrond_wasm::derive_imports!();

use elrond_wasm::types::heap::Vec;

#[derive(TypeAbi, TopEncode, TopDecode, PartialEq, Debug)]
pub struct StakeInfo<M: ManagedTypeApi> {
    pub address: ManagedAddress<M>,
    pub nft_nonce: Vec<u64>,
    pub lock_time: u64,
    pub unstake_time: u64,
}

L'astuce ici, c'est d'avoir transformé le champ nft_nonce en un vecteur de u64. Cela permet de stocker plusieurs valeurs dans ce champ.

Tu va maintenant modifier le fichier src/empty.rs pour prendre en compte cette modification et permettre la gestion de plusieurs NFTs par adresse.

Au niveau du bloc d'initialisation, on a juste rajouté un nouveau paramètre appelé nbr_of_nft_staked qui va nous permettre de stocker le nombre total de NFTs stakés, pour donner une information globale du contract à l'utilisateur.

#![no_std]

elrond_wasm::imports!();
use elrond_wasm::types::heap::Vec;

mod stake_info;
use stake_info::StakeInfo;

#[elrond_wasm::contract]
pub trait NftStaking {
    #[init]
    fn init(
        &self,
        nft_identifier: EgldOrEsdtTokenIdentifier,
        minimum_staking_days: u64,
        rewards_token_id: EgldOrEsdtTokenIdentifier,
        rewards_token_amount_per_day: BigUint,
        rewards_token_total_supply: BigUint,
    ) {
        self.nft_identifier().set(&nft_identifier);
        self.minimum_staking_days().set(&minimum_staking_days);
        self.rewards_token_id().set(&rewards_token_id);
        self.rewards_token_amount_per_day()
            .set(&rewards_token_amount_per_day);
        self.rewards_token_total_supply()
            .set(&rewards_token_total_supply);
        // if staking status is empty, set it to false
        if self.staking_status().is_empty() {
            self.staking_status().set(true);
        }
        // if staking end time is empty, set it to 0
        if self.staking_end_time().is_empty() {
            self.staking_end_time().set(0);
        }
        // if nbr of stakers is empty, set it to 0
        if self.nbr_of_stakers().is_empty() {
            self.nbr_of_stakers().set(0);
        }
        // if nbr of nft staked is empty, set it to 0
        if self.nbr_of_nft_staked().is_empty() {
            self.nbr_of_nft_staked().set(0);
        }
    }

Au niveau des storage_mapper et des view, tu peux déjà rajouter une view pour le nouveau champ getNbrOfNftStaked. Tu va également modifier la méthode getNftNonce pour qu'elle renvoie un vecteur de u64. Enfin, tu calcules le montant des récompenses à envoyer à l'utilisateur en fonction du nombre de NFTs stakés dans getCurrentRewards.

#[view(getCurrentRewards)]
fn get_current_rewards(&self, address: &ManagedAddress) -> BigUint {
    require!(!self.staking_info(&address).is_empty(), "You didn't stake!");
    let cur_time: u64 = self.blockchain().get_block_timestamp();

    require!(!self.staking_info(&address).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&address).get();

    // calculate rewards
    let mut from_time = cur_time;
    if !self.staking_status().get() {
        from_time = self.staking_end_time().get();
    }
    let mut staked_days = 0u64;
    if from_time > stake_info.lock_time {
        staked_days = (from_time - stake_info.lock_time) / 86400;
    }
    let rewards_amount = self.rewards_token_amount_per_day().get() * staked_days * stake_info.nft_nonce.len() as u64;

    return rewards_amount;
}

#[view(getNftNonce)]
fn get_nft_nonce(&self, address: &ManagedAddress) -> Vec<u64> {
    require!(!self.staking_info(&address).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&address).get();
    let nft_nonce: Vec<u64> = stake_info.nft_nonce;
    return nft_nonce;
}

#[view(getNbrOfNftStaked)]
#[storage_mapper("nbr_of_nft_staked")]
fn nbr_of_nft_staked(&self) -> SingleValueMapper<u64>;

Tu modifies la méthode stake pour prendre en compte non plus un seul paiement, c'est-à-dire un seul NFT, mais plusieurs paiements. C'est ici que tu vas donc construire le vecteur de NFTs stakés par l'utilisateur. Penses également à incrémenter ta nouvelle variable nbr_of_nft_staked.

#[payable("*")]
#[endpoint]
fn stake(&self) -> SCResult<()> {
    let payments: ManagedVec<EsdtTokenPayment<Self::Api>> =
        self.call_value().all_esdt_transfers();

    require!(self.staking_status().get(), "The staking is stopped");

    for payment in &payments {
        require!(
            payment.token_identifier == self.nft_identifier().get(),
            "Invalid nft identifier"
        );
        require!(payment.token_nonce != 0, "Invalid nft nonce");
        require!(payment.amount == 1, "You can only send 1 nft");
    }

    let caller: ManagedAddress = self.blockchain().get_caller();

    let cur_time: u64 = self.blockchain().get_block_timestamp();
    let unstake_time = cur_time + (self.minimum_staking_days().get() * 86400);

    if self.staking_info(&caller).is_empty() {
        let mut vec_nonce: Vec<u64> = Vec::new();
        for payment in &payments {
            vec_nonce.push(payment.token_nonce);
        }
        let stake_info = StakeInfo {
            address: self.blockchain().get_caller(),
            nft_nonce: vec_nonce,
            lock_time: cur_time,
            unstake_time: unstake_time,
        };
        self.staking_info(&self.blockchain().get_caller())
            .set(&stake_info);
        self.nbr_of_stakers().set(self.nbr_of_stakers().get() + 1);
    } else {
        let mut stake_info = self.staking_info(&caller).get();
        for payment in &payments {
            let mut vec_nonce: Vec<u64> = stake_info.nft_nonce.clone();
            vec_nonce.push(payment.token_nonce);
            stake_info.nft_nonce = vec_nonce;
        }
        stake_info.lock_time = cur_time;
        stake_info.unstake_time = unstake_time;
        self.staking_info(&caller).set(&stake_info);
    }
    self.nbr_of_nft_staked().set(self.nbr_of_nft_staked().get() + payments.len() as u64);

    Ok(())
}

Pour la méthode unstake, il suffira de parcourir le vecteur de NFTs stakés par l'utilisateur et de les transférer à l'utilisateur un par un. Attention, si beaucoup de NFTs sont stakés, cela risque de consommer beaucoup de gas.

#[endpoint]
fn unstake(&self) -> SCResult<()> {
    let caller: ManagedAddress = self.blockchain().get_caller();
    let cur_time: u64 = self.blockchain().get_block_timestamp();

    require!(!self.staking_info(&caller).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&caller).get();
    require!(
        stake_info.unstake_time <= cur_time,
        "You can't unlock staking nft yet."
    );

    let nft_identifier = self.nft_identifier().get();
    let nft_nonce = stake_info.nft_nonce;
    let nbr_of_nonce: u64 = nft_nonce.len() as u64;

    let amount = BigUint::from(1u32);

    // for each nft nonce, send nft back to caller
    for n in nft_nonce {
        self.send().direct(
            &caller,
            &nft_identifier,
            n,
            &amount,
        );
    }

    self.staking_info(&caller).clear();

    if self.nbr_of_stakers().get() >= 1 {
        self.nbr_of_stakers().set(self.nbr_of_stakers().get() - 1);
    } else {
        self.nbr_of_stakers().set(0);
    }
    if self.nbr_of_nft_staked().get() >= nbr_of_nonce {
        self.nbr_of_nft_staked().set(self.nbr_of_nft_staked().get() - nbr_of_nonce);
    } else {
        self.nbr_of_nft_staked().set(0);
    }

    Ok(())
}

Enfin, tu corriges la méthode claim pour calculer les récompenses en fonction du nombre de NFTs stakés, comme pour la view précédente appelée getCurrentRewards.

#[endpoint]
fn claim(&self) -> SCResult<()> {
    let caller: ManagedAddress = self.blockchain().get_caller();
    let cur_time: u64 = self.blockchain().get_block_timestamp();
    let rewards_token_total_supply = self.rewards_token_total_supply().get();

    require!(!self.staking_info(&caller).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&caller).get();

    let nft_nonce = stake_info.nft_nonce;
    let unstake_time = stake_info.unstake_time;
    let reward_token_id = self.rewards_token_id().get();

    // calculate rewards
    let mut from_time = cur_time;
    if !self.staking_status().get() {
        from_time = self.staking_end_time().get();
    }
    let mut staked_days = 0u64;
    if from_time > stake_info.lock_time {
        staked_days = (from_time - stake_info.lock_time) / 86400;
    }
    let rewards_amount = self.rewards_token_amount_per_day().get() * staked_days * nft_nonce.len() as u64;

    // check the supply
    require!(
        rewards_amount <= rewards_token_total_supply,
        "You can't claim rewards more than total supply."
    );

    // send rewards
    self.send()
        .direct(&caller, &reward_token_id, 0, &rewards_amount);

    // remove rewards amount from rewards_token_total_supply
    if rewards_token_total_supply >= rewards_amount {
        self.rewards_token_total_supply()
            .set(&(rewards_token_total_supply - rewards_amount));
    } else {
        self.rewards_token_total_supply().set(&BigUint::from(0u32));
    }

    // update staking_info
    self.staking_info(&caller).clear();
    let stake_info = StakeInfo {
        address: self.blockchain().get_caller(),
        nft_nonce: nft_nonce,
        lock_time: from_time,
        unstake_time: unstake_time,
    };
    self.staking_info(&self.blockchain().get_caller())
        .set(&stake_info);

    Ok(())
}

Les autres storage_mapper, view et owner endpoint restent inchangés :

#[view(getLockTime)]
fn get_lock_time(&self, address: &ManagedAddress) -> u64 {
    require!(!self.staking_info(&address).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&address).get();
    let lock_time: u64 = stake_info.lock_time;
    return lock_time;
}

#[view(getUnstakeTime)]
fn get_unstake_time(&self, address: &ManagedAddress) -> u64 {
    require!(!self.staking_info(&address).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&address).get();
    let unstake_time: u64 = stake_info.unstake_time;
    return unstake_time;
}

#[view(getNftIdentifier)]
#[storage_mapper("nft_identifier")]
fn nft_identifier(&self) -> SingleValueMapper<EgldOrEsdtTokenIdentifier>;

#[view(getMinimumStakingDays)]
#[storage_mapper("minimum_staking_days")]
fn minimum_staking_days(&self) -> SingleValueMapper<u64>;

#[view(getRewardsTokenId)]
#[storage_mapper("rewards_token_id")]
fn rewards_token_id(&self) -> SingleValueMapper<EgldOrEsdtTokenIdentifier>;

#[view(getRewardsTokenAmountPerDay)]
#[storage_mapper("rewards_token_amount_per_day")]
fn rewards_token_amount_per_day(&self) -> SingleValueMapper<BigUint>;

#[view(getStakingInfo)]
#[storage_mapper("staking_info")]
fn staking_info(&self, address: &ManagedAddress) -> SingleValueMapper<StakeInfo<Self::Api>>;

#[view(getStakingStatus)]
#[storage_mapper("staking_status")]
fn staking_status(&self) -> SingleValueMapper<bool>;

#[view(getStakingEndTime)]
#[storage_mapper("staking_end_time")]
fn staking_end_time(&self) -> SingleValueMapper<u64>;

#[view(getRewardsTokenTotalSupply)]
#[storage_mapper("rewards_token_total_supply")]
fn rewards_token_total_supply(&self) -> SingleValueMapper<BigUint>;

#[view(getNbrOfStakers)]
#[storage_mapper("nbr_of_stakers")]
fn nbr_of_stakers(&self) -> SingleValueMapper<u64>;

Tu re-compiles alors le tout avec erdpy :

erdpy contract build

Le code final est visible ici.

Déploiement

Ton fichier erdpy.json ne bouge pas, c'est exactement le même que pour le déploiement du contrat précédent. Tu peux donc déployer et faire tes transactions :

erdpy contract deploy
erdpy tx new --help

Concernant l'interface frontend pour le SC, tu peux suivre mon exemple ou faire ce qu'il te plait !

Environnement de développement en 2022

2022-09-19T00:00:00+02:00

Mon dernier article concernant mon environnement de développement datant de 2016, il était temps de faire une petite mise à jour de ce qui a changé depuis.

Distribution

Au revoir Arch Linux, et bonjour Debian Sid. J'adore toujours Arch Linux mais je n'ai plus autant de temps qu'avant pour bidouiller et customiser mon système. Il me faut un système stable et robuste, sans surprise, mais qui soit relativement à jour par rapport aux derniers paquets disponibles. Et clé en main.

Ça va faire 3 ans que je suis sur Debian Sid et je n'ai jamais eu de problème. C'est un bon compromis entre stabilité et fraicheur. Debian est devenu suffisamment user-friendly pour rendre obsolète toutes les distros basées sur elle comme Ubuntu ou Mint.

Tout ce qui me dérange un peu, c'est la migration vers Systemd, car je ne suis personnellement pas fan du principe. Je préfère les outils qui suivent plus la philosophie Unix, c'est-à-dire qui font une seule chose et le font bien. Mais bon, toutes les grosses distros ont désormais migré dessus, et à l'avenir il faudra peut-être plutôt regarder du côté de BSD pour avoir des outils plus simples.

Bureau

Gnome. Principalement parce que je suis passé d'un PC fixe à un portable avec un dock. Ce qui fait que j'ai beaucoup de périphériques à gérer et que je me connecte/déconnecte régulièrement à différents docks et écrans. Et Gnome gère automatiquement tout ça pour moi. Ok, y a plein de daemons qui tournent mais bon... C'est clairement du confort.

Je regarde toujours les tiling window managers de temps en temps comme i3, et j'ai donc testé Pop Shell qui permet du tiling avec Gnome. C'est pas trop mal mais finalement, sur un portable, je préfére utiliser Gnome avec le terminal top-down Guake.

Shell

J'ai migré de zsh à fish après m'être rendu compte que ma configuration customisée de zsh correspondait exactement au réglage par défaut de fish. Donc fish vanilla couplé à tmux pour la gestion des onglets et des sessions. Rien à configurer, juste ça marche par défaut. Magique.

Theme

Concernant les thèmes, je suis passé sur Dracula pour absolument tout. C'est un thème sombre parfait qui est disponible pour gnome, fish, vim, tmux, vs code, etc. L'ensemble de mon environnement est donc cohérent et j'aime beaucoup le résultat.

Police

J'utile désormais la police Fira Code depuis que je l'ai découverte. C'est une police monospace avec des ligatures, parfaite pour le développement.

Editeur de code

Visual Code Studio et Neovim.

VS Code a clairement remporté la bataille des éditeurs de texte face à Atom et Sublime Text. C'est un éditeur de code moderne, performant, avec un grand nombre de plugins. Et il est open source. Rien à redire de ce côté là, bravo Microsoft pour une fois.

Neovim prend bien la relève de Vim et c'est plutôt agréable de pouvoir utiliser Lua pour gérer les plugins.

Completion

J'ai participé à la beta de Github Copilot et j'y suis resté depuis. Un outil vraiment bluffant, et qui continue de me bluffer tous les jours. Je vois beaucoup de réticents mais vraiment... essayez-le, au moins pour votre culture. Pour des développements type Java avec une tonne de boilerplate à écrire, c'est juste génial.

Gestion des applications

Récemment j'ai découvert Flatpak et je suis plutôt fan du principe. J'avais testé Snap de Ubuntu à l'époque mais ça ne m'avait pas convaincu. Flatpak est plutôt rapide et simple à utiliser. C'est un peu plus sécurisé et ça permet de gérer les dépendances de manière plus propre. Le principe d'isolation me fait un peu penser aux installations des applications sur Android.

Du coup, désormais, dès que je dois installer une application externe propriétaire commme Spotify, Discord, Telegram ou Google Chrome, je passe par Flatpak.

En vrai, je me dis que Flatpak me permettrait même de rester sur Debian Stable plutôt que Sid et d'avoir des outils à jour grâce à lui. Mais bon, il y a encore quelques soucis de compatibilité avec certaines applications comme VS Code ou Steam par exemple.

Bonne découverte !

Smart Contract Elrond en Rust : NFT market

2022-07-07T00:00:00+02:00

C'est parti pour le troisième épisode de la série sur les Smart Contracts Elrond en Rust. Après avoir vu comment staker un NFT pour gagner des $DEAD et comment utiliser ces $DEAD pour voter dans notre DAO, on va pouvoir désormais acheter des NFTs sur notre propre marketplace avec des $DEAD.

Contexte

On doit pouvoir envoyer des NFTs sur un Smart Contract pour ainsi les vendre avec notre propre ESDT, ici $DEAD.

C'est une version très simplifié d'un marketplace dans le sens où :

on ne va pouvoir vendre les NFTs que d'une seule collection à la fois.
le prix de chaque NFT sera identique.

Si on veut avoir des prix différents ou utiliser une autre collection, il faudra soit changer les paramètres du Smart Contract, soit déployer un autre Smart Contract.

Dans ta dapp, ça pourra donner quelque-chose comme ça :

Smart Contract

Comme d'habitude, on crée un SC vide à l'aide de erdpy.

erdpy contract new market --template empty

Et on passe directement à l'écriture du SC dans src/empty.rs. Notre fonction d'initialisation va prendre en paramètre l'identifiant du token à utiliser pour les paiements, le prix d'un NFT ainsi que l'identifiant de la collection de NFT que l'on souhaite vendre.

#![no_std]

elrond_wasm::imports!();

/// An empty contract. To be used as a template when starting a new contract from scratch.
#[elrond_wasm::contract]
pub trait EmptyContract {
    #[init]
    fn init(&self, token_id: TokenIdentifier, price: BigUint, nft_identifier: TokenIdentifier) {
        self.token_id().set(&token_id);
        self.price().set(&price);
        self.nft_identifier().set(&nft_identifier);
        if self.bank().is_empty() {
            self.bank().set(BigUint::from(0u32));
        }
    }
}

On ajoute dans notre trait les storage_mapper et view des différentes variables que l'on va stocker dans le SC. L'élément bank correspond au montant total de $DEAD que l'on a dans notre SC suite aux divers paiements réalisés.

#[view(getBank)]
#[storage_mapper("bank")]
fn bank(&self) -> SingleValueMapper<BigUint>;

#[view(getTokenId)]
#[storage_mapper("token_id")]
fn token_id(&self) -> SingleValueMapper<TokenIdentifier>;

#[view(getNftIdentifier)]
#[storage_mapper("nft_identifier")]
fn nft_identifier(&self) -> SingleValueMapper<TokenIdentifier>;

#[view(getPrice)]
#[storage_mapper("price")]
fn price(&self) -> SingleValueMapper<BigUint>;

Ensuite, on ajoute quelques petites fonctions utilitaires pour l'administrateur du SC. On lui donne la possibilité de récupérer tous les fonds de la banque, de changer le prix de vente des NFTs ou de changer l'identifiant de la collection de NFT que l'on souhaite vendre. Attention à ne pas oublier le only_owner, sinon n'importe qui pourrait appeler ces fonctions !

#[only_owner]
#[endpoint]
fn withdraw(&self) -> SCResult<()> {

    let caller = self.blockchain().get_caller();
    let token_id = self.token_id().get();
    let bank = self.bank().get();

    self.send()
        .direct(&caller, &token_id, 0, &bank, b"withdraw successful");

    // reset the bank
    self.bank().set(BigUint::from(0u32));

    Ok(())
}

#[only_owner]
#[endpoint]
fn change_price(&self, price: BigUint) -> SCResult<()> {

    self.price().set(&price);

    Ok(())
}

#[only_owner]
#[endpoint]
fn change_nft_identifier(&self, nft_identifier: TokenIdentifier) -> SCResult<()> {

    self.nft_identifier().set(&nft_identifier);

    Ok(())
}

Enfin, on a la fonction principale de notre SC qui permet d'acheter des NFTs. On vérifie ici le type du token, le montant envoyé et l'identifiant de la collection de NFT. Le nonce envoyé en paramètre correspond au numéro du NFT que l'utilisateur veut acheter. Si tout est bon, on lui envoie le NFT via la fonction self.send().direct() et on incrémente la banque.

#[payable("*")]
#[endpoint]
fn buy(
    &self,
    #[payment_token] payment_token: TokenIdentifier,
    #[payment_amount] payment_amount: BigUint,
    nft_identifier: TokenIdentifier,
    nft_nonce: u64,
) -> SCResult<()> {
    require!(
        payment_token == self.token_id().get(),
        "Invalid payment token"
    );

    require!(
        payment_amount == self.price().get(),
        "Invalid payment amount"
    );

    require!(
        nft_identifier == self.nft_identifier().get(),
        "Invalid nft identifier"
    );

    let caller = self.blockchain().get_caller();

    let amount = BigUint::from(1u32);
    self.send().direct(&caller, &nft_identifier, nft_nonce, &amount , b"purchase successful");

    // Add the amount to the bank
    let bank = self.bank().get();
    self.bank().set(&bank + &payment_amount);


    Ok(())
}

Tu compiles ton SC avec erdpy pour vérifier que tout est ok :

erdpy contract build

Tu peux trouver le résultat final ici.

Déploiement

Comme dans les précédents épisodes, tu configures ton fichier erdpy.json pour déployer le SC sur devnet en lui passant les bons arguments. Le SC doit être payable via "metadata-payable": true et le pem de ton wallet doit se trouver sur ../../wallet/wallet-owner.pem.

Concernant les arguments, DEADBROS-fa8f0f correspond à l'identifiant du token, 100000000000000000000 au prix d'un NFT avec 18 decimals et DEAD1-2d86a5 est l'id de la collection de NFT à vendre.

{
    "configurations": {
        "default": {
            "proxy": "https://devnet-api.elrond.com",
            "chainID": "D"
        }
    },
    "contract":{
        "deploy":{
            "verbose": true,
            "bytecode": "output/buy_serum.wasm",
            "recall-nonce": true,
            "metadata-payable": true,
            "pem": "../../wallet/wallet-owner.pem",
            "gas-limit": 59999999,
            "arguments": [
                "str:DEADBROS-fa8f0f",
                "100000000000000000000",
                "str:DEAD1-2d86a5"
            ],
            "send": true,
            "outfile": "deploy-testnet.interaction.json"
        },
        "upgrade":{
            "verbose": true,
            "bytecode": "output/buy_serum.wasm",
            "recall-nonce": true,
            "metadata-payable": true,
            "pem": "../../wallet/wallet-owner.pem",
            "gas-limit": 59999999,
            "arguments": [
                "str:DEADBROS-fa8f0f",
                "100000000000000000000",
                "str:DEAD1-2d86a5"
            ],
            "send": true,
            "outfile": "deploy-testnet.interaction.json"
        }
    }
}

Tu peux alors déployer ton SC et tester les transactions avec erdpy.

erdpy contract deploy
erdpy tx new --help

N'oublie pas d'envoyer les NFTs que tu souhaites vendre à l'adresse de ton SC !

Smart Contract Elrond en Rust : NFT staking

2022-07-07T00:00:00+02:00

Voici le deuxième épisode de cette série sur les Smart Contracts Elrond en Rust. On va parler ici d'un sujet qui intéresse pas mal de monde dans l'univers des NFTs : le staking.

On suppose que tu as déjà tous les outils pour te lancer dans l'aventure. Si ce n'est pas le cas, jettes un oeil au premier épisode.

Contexte

C'est une version simple du staking qui est largement améliorable, mais ça permet d'avoir un premier jet fonctionnel.

L'idée ici est de créer un SC qui va être une pool de staking. Chaque utilisateur va pouvoir envoyer un NFT dans cette pool, et pourra réclamer journalièrement des tokens ESDT en récompense.

On a deux limitations dans cette version :

Chaque utilisateur représenté par une adresse Elrond ne peut envoyer qu'un seul NFT dans la pool.
Les récompenses sont à réclamer régulièrement et ne sont pas directement attribuées.
Une seule collection de NFT est supportée. Donc pour faire une pool de staking sur une autre collection, il faudra déployer un deuxième SC.

Dans ta dapp, ça pourra ressembler à ça par exemple :

Smart Contract

Comme dans le premier épisode, on crée un SC vide à l'aide de erdpy.

erdpy contract new staking --template empty

Ensuite, dans un fichier src/stake_info.rs, on va avoir notre structure qui nous permettra de stocker les informations de staking de l'utilisateur.

elrond_wasm::imports!();
elrond_wasm::derive_imports!();

#[derive(TypeAbi, TopEncode, TopDecode, PartialEq, Debug)]
pub struct StakeInfo<M: ManagedTypeApi> {
    pub address: ManagedAddress<M>,
    pub nft_nonce: u64,
    pub lock_time: u64,
    pub unstake_time: u64,
}

On y stocke donc :

son adresse Elrond.
le nonce de son NFT, qui représente le numéro du NFT dans la collection.
le moment où le NFT est locké, c-à-d quand il est envoyé dans la pool.
le moment où le NFT peut être déstaker via unstake_time.

On passe ensuite à l'écriture du SC dans src/empty.rs.

On initialise les différents arguments de notre SC via la fonction init.

nft_identifier : l'identifiant de la collection NFT concernée.
minimum_staking_days : le nombre de jours minimum avant de pouvoir déstaker son NFT.
rewards_token_id : l'identifiant du token ESDT pour les récompenses.
rewards_token_amount_per_day : le montant par jour des récompenses du staking.
rewards_token_total_supply : le nombre total de tokens disponibles dans le SC.

Et on initie quelques paramètres supplémentaires comme :

staking_status : permet de définir si la pool est démarrée où non.
staking_end_time : permet de définir le moment où la pool sera fermée.
nbr_of_stakers : permet de définir le nombre de stakers dans la pool.

#![no_std]

elrond_wasm::imports!();

mod stake_info;
use stake_info::StakeInfo;

#[elrond_wasm::contract]
pub trait NftStaking {
    #[init]
    fn init(
        &self,
        nft_identifier: TokenIdentifier,
        minimum_staking_days: u64,
        rewards_token_id: TokenIdentifier,
        rewards_token_amount_per_day: BigUint,
        rewards_token_total_supply: BigUint,
    ) {
        self.nft_identifier().set(&nft_identifier);
        self.minimum_staking_days().set(&minimum_staking_days);
        self.rewards_token_id().set(&rewards_token_id);
        self.rewards_token_amount_per_day()
            .set(&rewards_token_amount_per_day);
        self.rewards_token_total_supply()
            .set(&rewards_token_total_supply);
        // if staking status is empty, set it to false
        if self.staking_status().is_empty() {
            self.staking_status().set(true);
        }
        // if staking end time is empty, set it to 0
        if self.staking_end_time().is_empty() {
            self.staking_end_time().set(0);
        }
        // if nbr of stakers is empty, set it to 0
        if self.nbr_of_stakers().is_empty() {
            self.nbr_of_stakers().set(0);
        }
    }
}

Tu peux alors définir les storage_mapper et les view pour ces différents paramètres. Le storage_mapper appelé staking_info va permettre de stoker un objet StakeInfo par adresse Elrond via la définition SingleValueMapper<StakeInfo<Self::Api>>.

#[view(getNftIdentifier)]
#[storage_mapper("nft_identifier")]
fn nft_identifier(&self) -> SingleValueMapper<TokenIdentifier>;

#[view(getMinimumStakingDays)]
#[storage_mapper("minimum_staking_days")]
fn minimum_staking_days(&self) -> SingleValueMapper<u64>;

#[view(getRewardsTokenId)]
#[storage_mapper("rewards_token_id")]
fn rewards_token_id(&self) -> SingleValueMapper<TokenIdentifier>;

#[view(getRewardsTokenAmountPerDay)]
#[storage_mapper("rewards_token_amount_per_day")]
fn rewards_token_amount_per_day(&self) -> SingleValueMapper<BigUint>;

#[view(getStakingInfo)]
#[storage_mapper("staking_info")]
fn staking_info(&self, address: &ManagedAddress) -> SingleValueMapper<StakeInfo<Self::Api>>;

#[view(getStakingStatus)]
#[storage_mapper("staking_status")]
fn staking_status(&self) -> SingleValueMapper<bool>;

#[view(getStakingEndTime)]
#[storage_mapper("staking_end_time")]
fn staking_end_time(&self) -> SingleValueMapper<u64>;

#[view(getRewardsTokenTotalSupply)]
#[storage_mapper("rewards_token_total_supply")]
fn rewards_token_total_supply(&self) -> SingleValueMapper<BigUint>;

#[view(getNbrOfStakers)]
#[storage_mapper("nbr_of_stakers")]
fn nbr_of_stakers(&self) -> SingleValueMapper<u64>;

On passe ensuite à la fonction de staking. Celle-ci doit être payable car on y envoit son NFT. Il faut vérifier le que le staking est démarré et que le NFT envoyé est bien dans la collection. On vérifie aussi qu'un NFT n'est pas déjà locké par cet utilisateur.

On définit alors les différents paramètres de son StakeInfo que l'on sauvegarde dans la blockchain et on incrémente le nbr_of_stakers. On ajoute également le moment où il pourra déstaker son NFT.

Ne pas oublier le Ok(()) à la fin !

#[payable("*")]
#[endpoint]
fn stake(&self) -> SCResult<()> {
    let payment: EsdtTokenPayment<Self::Api> = self.call_value().payment();
    let payment_token = payment.token_identifier;
    let payment_nonce = payment.token_nonce;
    let payment_amount = payment.amount;
    require!(self.staking_status().get(), "The staking is stopped");
    require!(
        payment_token == self.nft_identifier().get(),
        "Invalid nft identifier"
    );
    require!(payment_nonce != 0, "Invalid nft nonce");
    require!(payment_amount == 1, "You can only send 1 nft");

    let caller: ManagedAddress = self.blockchain().get_caller();

    require!(
        self.staking_info(&caller).is_empty(),
        "You have already staked."
    );

    let cur_time: u64 = self.blockchain().get_block_timestamp();
    let unstake_time = cur_time + (self.minimum_staking_days().get() * 86400);

    let stake_info = StakeInfo {
        address: self.blockchain().get_caller(),
        nft_nonce: payment_nonce,
        lock_time: cur_time,
        unstake_time: unstake_time,
    };

    self.staking_info(&self.blockchain().get_caller())
        .set(&stake_info);

    self.nbr_of_stakers().set(self.nbr_of_stakers().get() + 1);

    Ok(())
}

Notre utilisateur peut désormais staker son NFT. Maintenant il faut qu'il puisse le déstaker. On vérifie qu'il a bien un StakeInfo stocké dans la blockchain avec son adresse et qu'il a bien dépassé le nombre minimum de jours de staking.

Si c'est le cas, on lui envoie son NFT via self.send().direct(), on supprime son entrée StakeInfo et on décrémente le nbr_of_stakers.

#[endpoint]
fn unstake(&self) -> SCResult<()> {
    let caller: ManagedAddress = self.blockchain().get_caller();
    let cur_time: u64 = self.blockchain().get_block_timestamp();

    require!(!self.staking_info(&caller).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&caller).get();
    require!(
        stake_info.unstake_time <= cur_time,
        "You can't unlock staking nft yet."
    );

    let nft_identifier = self.nft_identifier().get();
    let nft_nonce = stake_info.nft_nonce;

    let amount = BigUint::from(1u32);
    self.send().direct(
        &caller,
        &nft_identifier,
        nft_nonce,
        &amount,
        b"unstake successful",
    );

    self.staking_info(&caller).clear();

    if self.nbr_of_stakers().get() > 0 {
        self.nbr_of_stakers().set(self.nbr_of_stakers().get() - 1);
    }

    Ok(())
}

Troisème grosse étape après le staking et le déstaking : la possibilté de réclamer ses récompenses. On calcule ses récompenses en fonction du nombre de jours de staking et du moment où il a locké son NFT. On vérifie également qu'il reste bien des tokens disponibles dans le SC.

Après avoir envoyé ses récompenses, on met à jour son StakeInfo en redéfinissant son lock time à maintenant. Ce qui va permet de relancer le calcul des futurs récompenses à partir de là.

#[endpoint]
fn claim(&self) -> SCResult<()> {
    let caller: ManagedAddress = self.blockchain().get_caller();
    let cur_time: u64 = self.blockchain().get_block_timestamp();
    let rewards_token_total_supply = self.rewards_token_total_supply().get();

    require!(!self.staking_info(&caller).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&caller).get();

    let nft_nonce = stake_info.nft_nonce;
    let unstake_time = stake_info.unstake_time;
    let reward_token_id = self.rewards_token_id().get();

    // calculate rewards
    let mut from_time = cur_time;
    if !self.staking_status().get() {
        from_time = self.staking_end_time().get();
    }
    let mut staked_days = 0u64;
    if from_time > stake_info.lock_time {
        staked_days = (from_time - stake_info.lock_time) / 86400;
    }
    let rewards_amount = self.rewards_token_amount_per_day().get() * staked_days;

    // check the supply
    require!(
        rewards_amount <= rewards_token_total_supply,
        "You can't claim rewards more than total supply."
    );

    // send rewards
    self.send()
        .direct(&caller, &reward_token_id, 0, &rewards_amount, &[]);

    // remove rewards amount from rewards_token_total_supply
    if rewards_token_total_supply >= rewards_amount {
        self.rewards_token_total_supply()
            .set(&(rewards_token_total_supply - rewards_amount));
    } else {
        self.rewards_token_total_supply().set(&BigUint::from(0u32));
    }

    // update staking_info
    self.staking_info(&caller).clear();
    let stake_info = StakeInfo {
        address: self.blockchain().get_caller(),
        nft_nonce: nft_nonce,
        lock_time: from_time,
        unstake_time: unstake_time,
    };
    self.staking_info(&self.blockchain().get_caller())
        .set(&stake_info);

    Ok(())
}

Le plus gros est fait ! On ajoute quelques fonctions d'administration supplémentaires pour le possesseur du SC, à savoir :

set_rewards_token_total_supply : pour définir le nombre total de tokens disponibles dans la pool pour récompenser les utilisateurs.
set_rewards_token_amount_per_day : la possibilité de modifier le nombre de récompenses journalières.
withdraw : la possibilité de récupérer tous les tokens du SC, au cas où.
stop_staking : la possibilité de stopper le staking.
restart_staking : la possibilité de relancer le staking.

#[only_owner]
#[endpoint]
fn set_rewards_token_total_supply(&self, total_supply: BigUint) -> SCResult<()> {
    self.rewards_token_total_supply().set(&total_supply);
    Ok(())
}

// set rewards_token_amount_per_day
#[only_owner]
#[endpoint]
fn set_rewards_token_amount_per_day(&self, amount: BigUint) -> SCResult<()> {
    self.rewards_token_amount_per_day().set(&amount);
    Ok(())
}

#[only_owner]
#[endpoint]
fn withdraw(&self, amount: BigUint) -> SCResult<()> {
    let caller = self.blockchain().get_caller();

    let token_id = self.rewards_token_id().get();

    self.send()
        .direct(&caller, &token_id, 0, &amount, b"withdraw successful");

    Ok(())
}

#[only_owner]
#[endpoint]
fn restart_staking(&self) -> SCResult<()> {
    self.staking_end_time().set(0);
    self.staking_status().set(true);
    Ok(())
}

#[only_owner]
#[endpoint]
fn stop_staking(&self) -> SCResult<()> {
    let cur_time: u64 = self.blockchain().get_block_timestamp();
    self.staking_end_time().set(cur_time);
    self.staking_status().set(false);
    Ok(())
}

Enfin, tu peux ajouter quelques vues qui seront utiles pour l'affichage dans ta dapp.

get_current_rewards : pour afficher le montant des récompenses récupérables actuellement.
get_nft_nonce : pour afficher le numéro du NFT que l'utilisateur a locké.
get_lock_time : pour afficher le moment où l'utilisateur a locké son NFT.
get_unstake_time : pour afficher le moment où l'utilisateur peut déstaker son NFT.

#[view(getCurrentRewards)]
fn get_current_rewards(&self, address: &ManagedAddress) -> BigUint {
    require!(!self.staking_info(&address).is_empty(), "You didn't stake!");
    let cur_time: u64 = self.blockchain().get_block_timestamp();

    require!(!self.staking_info(&address).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&address).get();

    // calculate rewards
    let mut from_time = cur_time;
    if !self.staking_status().get() {
        from_time = self.staking_end_time().get();
    }
    let mut staked_days = 0u64;
    if from_time > stake_info.lock_time {
        staked_days = (from_time - stake_info.lock_time) / 86400;
    }
    let rewards_amount = self.rewards_token_amount_per_day().get() * staked_days;

    return rewards_amount;
}

#[view(getNftNonce)]
fn get_nft_nonce(&self, address: &ManagedAddress) -> u64 {
    require!(!self.staking_info(&address).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&address).get();
    let nft_nonce: u64 = stake_info.nft_nonce;
    return nft_nonce;
}

#[view(getLockTime)]
fn get_lock_time(&self, address: &ManagedAddress) -> u64 {
    require!(!self.staking_info(&address).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&address).get();
    let lock_time: u64 = stake_info.lock_time;
    return lock_time;
}

#[view(getUnstakeTime)]
fn get_unstake_time(&self, address: &ManagedAddress) -> u64 {
    require!(!self.staking_info(&address).is_empty(), "You didn't stake!");
    let stake_info = self.staking_info(&address).get();
    let unstake_time: u64 = stake_info.unstake_time;
    return unstake_time;
}

Tu utilises alors à nouveau erdpy pour compiler ton SC et vérifier que tout se passe bien :

erdpy contract build

Le code final est visible ici.

Déploiement

Pour déployer, il te faut un fichier erdpy.json à la racine du projet. Comme pour l'épisode précédent, on va déployer sur devnet et on suppose que le pem de ton wallet est dans ../../wallet/wallet-owner.pem.

Concernant les arguments ici :

BACKGROUND-35c061 : l'id de la collection NFT concernée
10 : nombre de jours minimum de staking
DEADBROS-fa8f0f : l'id de l'ESDT utilisé pour les récompenses
100000000000000000000 : le montant journalier des récompenses. C'est sur 18 décimals, donc en vrai on a 100 $DEAD de récompenses.
6000000000000000000000000 : le nombre total de tokens disponibles dans le SC. 6 millions donc.

{
    "configurations": {
        "default": {
            "proxy": "https://devnet-api.elrond.com",
            "chainID": "D"
        }
    },
    "contract":{
        "deploy":{
            "verbose": true,
            "bytecode": "output/nft_staking.wasm",
            "recall-nonce": true,
            "metadata-payable": true,
            "pem": "../../wallet/wallet-owner.pem",
            "gas-limit": 59999999,
            "arguments": [
                "str:BACKGROUND-35c061",
                "10",
                "str:DEADBROS-fa8f0f",
                "100000000000000000000",
                "6000000000000000000000000"
            ],
            "send": true,
            "outfile": "deploy-testnet.interaction.json"
        },
        "upgrade":{
            "verbose": true,
            "bytecode": "output/nft_staking.wasm",
            "recall-nonce": true,
            "metadata-payable": true,
            "pem": "../../wallet/wallet-owner.pem",
            "gas-limit": 59999999,
            "arguments": [
                "str:BACKGROUND-35c061",
                "10",
                "str:DEADBROS-fa8f0f",
                "100000000000000000000",
                "6000000000000000000000000"
            ],
            "send": true,
            "outfile": "deploy-testnet.interaction.json"
        }
    }
}

Le SC doit être payable via "metadata-payable": true, car ça va nous permettre d'y envoyer directement le nombre total de tokens pour les récompenses via une transaction standard avec Maiar.

Tu peux alors déployer et tester les transactions avec erdpy.

erdpy contract deploy
erdpy tx new --help

Il ne te reste plus qu'à coder une interface frontend pour le SC.

Bon courage ! Et n'hésite pas à améliorer tout ça et à nous faire un retour !

Smart Contract Elrond en Rust : DAO vote

2022-07-06T00:00:00+02:00

Allez, c'est parti pour une série d'articles concernant l'écriture de Smart Contract Elrond en Rust. Etant dans l'équipe d'un projet NFT sur Elrond, j'ai pu explorer certains facettes de cette blockchain.

Contexte

On va commencer par écrire un SC en Rust pour implémenter le système de vote d'une DAO. Imaginons que la DAO de notre projet NFT a son propre token (ici $DEAD). Et que nous souhaitons mettre en place un système de vote où les membres peuvent utiliser des $DEAD pour voter.

Ici, le nombre de $DEAD accumulés équivaut à une puissance de vote. Les membres qui ont plus de tokens ont donc plus de pouvoir dans la DAO.

On aura donc une question stockée dans le SC et la possibilité de voter oui ou non avec des $DEAD. A la fin du vote, les membres doivent pouvoir récupérer leurs tokens.

Tools

Tu vas avoir besoin de Python 3, de Rust et de Erdpy.

sudo apt install libncurses5 python3
wget -O erdpy-up.py https://raw.githubusercontent.com/ElrondNetwork/elrond-sdk-erdpy/master/erdpy-up.py
python3.8 erdpy-up.py
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Prends ton éditeur préféré et c'est parti !

Smart Contract

On va utiliser un template vide à l'aide de erdpy pour créer un SC. Tu peux trouver des informations complémentaire dans la documentation officielle, notamment pour te créer le fichier pem de ton wallet nécessaire au déploiement en production.

erdpy contract new vote --template empty

Pour faire ça proprement, on va créer un fichier vote_info.rs dans src qui va contenir la structure de notre vote. On va y stocker l'adresse Elrond du votant ainsi qui le nombre de $DEAD qu'il a utilisé pour voter.

elrond_wasm::imports!();
elrond_wasm::derive_imports!();

#[derive(TypeAbi, TopEncode, TopDecode, PartialEq, Debug)]
pub struct VoteInfo<M: ManagedTypeApi> {
    pub address: ManagedAddress<M>,
    pub amount: BigUint<M>,
}

Le fichier qui va principalement nous intéresser est src/empty.rs.

A chaque déploiement ou mise à jour du smart contract, la fonction init est appelée. Il faut donc faire attention à ne pas écraser des valeurs !

On va prendre en paramètre la question et l'identifiant du token que l'on souhaite utiliser pour voter. Et on initialise à 0 le nombre total de vote "oui" et de vote "non", et on démarre le vote.

#![no_std]

elrond_wasm::imports!();

mod vote_info;
use vote_info::VoteInfo;
use elrond_wasm::types::heap::BoxedBytes;

#[elrond_wasm::contract]
pub trait Vote {
    // La fonction d'initialisation au déployement du contrat
    // On définit la question et les réponses possibles
    #[init]
    fn init(&self, question: BoxedBytes, token_id: TokenIdentifier) {
        self.question().set(&question);
        self.token_id().set(&token_id);
        if self.yes().is_empty() {
            self.yes().set(BigUint::from(0u32));
        }
        if self.no().is_empty() {
            self.no().set(BigUint::from(0u32));
        }
        if self.in_progress().is_empty() {
            self.in_progress().set(1u32);
        }
    }
}

En bas de notre trait, on va définir l'ensemble des valeurs que l'on souhaite stocker dans le SC. C'est directement stocké dans la blockchain via storage_mapper et on peut visualiser les données depuis une dapp par exemple en appelant les méthodes de view.

// La question
#[view(getQuestion)]
#[storage_mapper("question")]
fn question(&self) -> SingleValueMapper<BoxedBytes>;

// Le nombre de votes pour la réponse "oui"
#[view(getYes)]
#[storage_mapper("yes")]
fn yes(&self) -> SingleValueMapper<BigUint>;

// Le nombre de votes pour la réponse "non"
#[view(getNo)]
#[storage_mapper("no")]
fn no(&self) -> SingleValueMapper<BigUint>;

// Le token utilisé pour les votes
#[view(getTokenId)]
#[storage_mapper("token_id")]
fn token_id(&self) -> SingleValueMapper<TokenIdentifier>;

// Si le vote est terminé
#[view(getInProgress)]
#[storage_mapper("in_progress")]
fn in_progress(&self) -> SingleValueMapper<u32>;

// L'information du votant
#[view(getVoteInfo)]
#[storage_mapper("vote_info")]
fn vote_info(&self, address: &ManagedAddress) -> SingleValueMapper<VoteInfo<Self::Api>>;

Ensuite, on va créer nos deux fonctions vote_yes et vote_no. Il y a sûrement moyen de mutualiser ces deux fonctions, mais j'ai fait au plus rapide.

Il faut mettre quelques garde-fous, notamment pour vérifier que le type de token envoyé est le bon et que le vote est toujours en cours.

Cette fonction doit donc être payable. Son fonctionnement est tout simple. On incrémente le nombre total de "oui" ou de "non", et on ajoute ou met à jour l'information du votant.

Le Ok(()) à la fin est important, car il permet de confirmer que la transaction s'est bien effectuée.

#[payable("*")]
#[endpoint]
fn vote_yes(
    &self,
    #[payment_token] payment_token: TokenIdentifier,
    #[payment_amount] payment_amount: BigUint,
) -> SCResult<()> {
    require!(
        payment_token == self.token_id().get(),
        "Invalid payment token"
    );

    require!(
        self.in_progress().get() == 1u32,
        "the vote is over"
    );

    let yes = self.yes().get();
    self.yes().set(&yes + &payment_amount);

    // save info about the voter
    let caller: ManagedAddress = self.blockchain().get_caller();

    // if vote info exists, update it
    if !self.vote_info(&caller).is_empty() {
        let new_vote_info = VoteInfo {
            address: self.blockchain().get_caller(),
            amount: self.vote_info(&caller).get().amount + &payment_amount,
        };
        self.vote_info(&caller).clear();
        self.vote_info(&caller).set(&new_vote_info);
    } else {
        // else create a new vote info
        let new_vote_info = VoteInfo {
            address: self.blockchain().get_caller(),
            amount: payment_amount,
        };
        self.vote_info(&caller).set(&new_vote_info);
    }

    Ok(())
}

// On peut voter non en envoyant autant de tokens que souhaité
#[payable("*")]
#[endpoint]
fn vote_no(
    &self,
    #[payment_token] payment_token: TokenIdentifier,
    #[payment_amount] payment_amount: BigUint,
) -> SCResult<()> {
    require!(
        payment_token == self.token_id().get(),
        "Invalid payment token"
    );

    require!(
        self.in_progress().get() == 1u32,
        "the vote is over"
    );

    let no = self.no().get();
    self.no().set(&no + &payment_amount);

    // save info about the voter
    let caller: ManagedAddress = self.blockchain().get_caller();

    // if vote info exists, update it
    if !self.vote_info(&caller).is_empty() {
        let new_vote_info = VoteInfo {
            address: self.blockchain().get_caller(),
            amount: self.vote_info(&caller).get().amount + &payment_amount,
        };
        self.vote_info(&caller).clear();
        self.vote_info(&caller).set(&new_vote_info);
    } else {
        // else create a new vote info
        let new_vote_info = VoteInfo {
            address: self.blockchain().get_caller(),
            amount: payment_amount,
        };
        self.vote_info(&caller).set(&new_vote_info);
    }

    Ok(())
}

A la fin du vote, le votant doit pouvoir récupérer ses tokens. On créé donc une fonction qui sera appelée par le votant via un bouton dans la dapp. On effectue donc une transaction pour lui envoyer le montant total de ses tokens stockés dans le SC via la fonction self.send().direct().

#[endpoint]
fn withdraw_my_amount(&self) -> SCResult<()> {
    require!(
        self.in_progress().get() == 0u32,
        "the vote is not over"
    );

    let caller: ManagedAddress = self.blockchain().get_caller();

    require!(!self.vote_info(&caller).is_empty(), "Nothing to withdraw!");
    let vote_info = self.vote_info(&caller).get();

    let my_amount = vote_info.amount;
    let token_id = self.token_id().get();

    self.send()
        .direct(&caller, &token_id, 0, &my_amount, &[]);

    self.vote_info(&caller).clear();

    Ok(())
}

On donne également la possibilité à l'administrateur du smart contract de retirer tous les tokens, au cas où. On additionne ici le total des "oui" et des "non" et on envoie le tout à l'administrateur.

#[only_owner]
#[endpoint]
fn withdraw(&self) -> SCResult<()> {
    require!(
        self.in_progress().get() == 0u32,
        "the vote is not over"
    );

    let caller = self.blockchain().get_caller();

    let yes = self.yes().get();
    let no = self.no().get();
    let token_id = self.token_id().get();
    let amount = &yes + &no;

    self.send()
        .direct(&caller, &token_id, 0, &amount, b"withdraw successful");

    Ok(())
}

Enfin, on ajoute quelques petites fonctions pratiques.

Par exemple, pour stopper le vote :

#[only_owner]
#[endpoint]
fn finish_vote(&self) -> SCResult<()> {
    self.in_progress().set(0u32);

    Ok(())
}

Ou pour changer la question :

#[only_owner]
#[endpoint]
fn change_question(&self, question: BoxedBytes) -> SCResult<()> {
    self.question().set(&question);

    Ok(())
}

Attention à bien utiliser only_owner, sinon n'importe qui pourra appeler ces fonctions !

Enfin, pour récupérer le nombre total de tokens utilisés par le votant :

#[view(getMyAmount)]
fn get_my_amount(&self, address: &ManagedAddress) -> BigUint {
    require!(!self.vote_info(&address).is_empty(), "Nothing to withdraw!");
    let vote_info = self.vote_info(&address).get();
    let amount = vote_info.amount;
    return amount;
}

Et voilà ! Tu peux jeter un oeil au résultat final sur mon github.

Pour tester si tout fonctionne, tu utilise erdpy pour compiler ton SC :

erdpy contract build

Et pour déployer, il te faut créer à la racine du projet un fichier erdpy.json avec les informations nécessaires au déploiement. Ici, on déploie sur devnet. Tu pourras trouver dans arguments les 2 arguments nécessaires au init du SC. DEADBROS-fa8f0f est l'id du token $DEAD sur devnet.

{
    "configurations": {
        "default": {
            "proxy": "https://devnet-api.elrond.com",
            "chainID": "D"
        }
    },
    "contract":{
        "deploy":{
            "verbose": true,
            "bytecode": "output/vote.wasm",
            "recall-nonce": true,
            "pem": "../../wallet/wallet-owner.pem",
            "gas-limit": 59999999,
            "arguments": [
                "str:Do you approve of the following plan regarding Dawn DeadBrothers funds: 35% EGLD staking, 35% LKMEX farming, 5% foundation, 5% charity, 10% marketing, 10% team ?",
                "str:DEADBROS-fa8f0f"
            ],
            "send": true,
            "outfile": "deploy-testnet.interaction.json"
        },
        "upgrade":{
            "verbose": true,
            "bytecode": "output/vote.wasm",
            "recall-nonce": true,
            "pem": "../../wallet/wallet-owner.pem",
            "gas-limit": 59999999,
            "arguments": [
                "str:Do you approve of the following plan regarding Dawn DeadBrothers funds: 35% EGLD staking, 35% LKMEX farming, 5% foundation, 5% charity, 10% marketing, 10% team ?",
                "str:DEADBROS-fa8f0f"
            ],
            "send": true,
            "outfile": "deploy-testnet.interaction.json"
        }
    }
}

On imagine ici que tu as le pem de ton wallet dans ../../wallet/wallet-owner.pem. N'oublie pas d'utiliser un faucet pour récupérer des EGLD de tests, car le déploiement a un coût !

Tu déploie le tout et tu croises les doigts !

erdpy contract deploy

Tu peux désormais utiliser erdpy pour effectuer des transactions et tester les différentes fonctions de ton SC.

erdpy tx new --help

Ou alors tu peux directement passer à l'écriture de ton application frontend !

Avec une dapp associée, ça peut ressembler à ça :

Have fun !

Mon environnement python en 2022

2022-01-28T00:00:00+01:00

Pour cette nouvelle année 2022, on va voir ensemble les quelques librairies plutôt cools pour se faire un environnement de dev sympa et efficace en python ! On teste avec python 3.9 car il y a encore des soucis de compatibilité pour certaines librairies avec python 3.10.

Versions de python

Pour gérer les différentes versions de python sur ta machine, il est plutôt pratique d'utiliser pyenv. Pour les devs JS, c'est un équivalent à nvm et à n mais pour python.

Pour l'installer et l'utiliser rien de plus simple :

sudo apt-get install aria2 build-essential curl git libbz2-dev libffi-dev liblzma-dev \
libncurses5-dev libncursesw5-dev libreadline-dev libsqlite3-dev libssl-dev llvm make tk-dev wget xz-utils zlib1g-dev
curl -L https://github.com/pyenv/pyenv-installer/raw/master/bin/pyenv-installer | bash

export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"

pyenv install 3.9.10

Après, si tu n'as pas besoin de gérer plein de versions différentes régulièrement, tu peux te cantonner à utiliser les packages de ta distro.

Environnement virtuel et packaging

Pour ma part, fini les virtualenv, virtualenvwrapper et setup.py, et place à poetry et au fichier pyproject.toml !

La communauté python peine depuis un moment à avoir de bons outils pour gérer le packaging des applications et poetry vient apporter une solution à tout ça. Certains diront que sa non-compatibilité avec les fichiers setup.py est le mal absolu car non-standard, ce qui n'est pas complètement faux ... Mais cet outil est tellement pratique que j'en ai fait fi.

On l'installe et on initie un nouveau projet avec un venv encapsulé automatiquement :

curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -

poetry new --src myapp
cd myapp
poetry add black isort
echo 'print("Hello World!")' > src/main.py
poetry run python src/main.py
poetry build
poetry publish

Ici on a ajouté les librairies black et isort dans les dépendances du projet et on a exécuté notre script python "Hello World!". Ensuite, on a buildé un sdist et un wheel qu'on a déployé sur PyPI.

Et voici aperçu du fameux fichier pyproject.toml généré :

[tool.poetry]
name = "myapp"
version = "0.1.0"
description = ""
authors = ["mobo"]

[tool.poetry.dependencies]
python = "^3.9"
black = "^21.12b0"
isort = "^5.10.1"

[tool.poetry.dev-dependencies]
pytest = "^5.2"

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"

Quel gain de temps énorme !

Formattage du code

Black domine désormais de très loin tous les linters et autres formatteurs de code python. Plus besoin de cumuler et de configurer une tonne d'outils comme pep8, flake8, pylint, pyflakes, pychecker. On dégage tout ça et on utilise que black. Il va se charger de formatter correctement ton code, point barre. C'est l'équivalent du gofmt de golang.

Est-ce que le rendu est parfait ? Non. Est-ce qu'il est suffisamment bon pour qu'on arrête de se poser la question de comment formater notre code ? Oui, mille fois oui.

On l'installe et on l'exécute sur notre projet et c'est tout. Pour automatiser tout ça, tu peux même le mettre sur un git hook, au commit par exemple.

poetry add black
poetry run black src/

Si tu es quelqu'un de tatillon qui aime avoir ses importations bien ordonnées, tu peux utiliser isort. Comme pour black, tu l'installes et tu le lances sur ton projet et c'est réglé :

poetry add isort
poetry run isort src/

Typage statique

Suite au succès de typescript pour le typage statique de javascript, une sorte d'équivalent a vu le jour pour python sous la forme d'une librairie optionnelle appelée mypy. Cette librarie permet d'annoter notre code pour expliciter les types de nos arguments, fonctions, classes, etc ...

Tu peux écrire ce script par exemple :

def hello(name: str, age: int) -> str:
        return f"Hello {name}, you are {age} years old."

print(hello("Jean", 18))

Et tu verifies le typage à l'aide de la commande suivante :

poetry add mypy
poetry run mypy src/

Tests unitaires

Rien de neuf sous le soleil, on utilise toujours pytest qui est installé par defaut avec poetry :

poetry run pytest

Il est même possible d'utiliser tox avec poetry pour exécuter les tests sous plusieurs environnements avec un tox.ini ressemblant à ça :

[tox]
isolated_build = true
envlist = py27, py36

[testenv]
whitelist_externals = poetry
commands =
    poetry install -v
    poetry run pytest tests/

Développement web

Rien de révolutionnaire ici non plus. Dans 80% des cas, pour les applications moyennes et complexes, django-rest-framework couplé au framework front-end de ton choix fera le café.

Pour les 20% de cas d'applications très simples, je reste sur le framework bottle et l'orm peewee, qui ne m'ont jamais fait défaut.

Je trouve que le combo flask + sqlalchemy est une espèce d'entre-deux qui ne correspond à aucun de mes cas d'usage.

Bon dev à tous !

Pico-8, mon coup de coeur !

2021-03-23T00:00:00+01:00

Pico-8 est ce qu'on appelle une Fantasy Console, c'est-à-dire qu'il s'agit d'une console virtuelle 8 bits imaginaire. C'est un peu comme une cousine de la Game Boy n'ayant jamais existée. Et comme toutes les consoles, elle a des contraintes et des limitations. Sa résolution est fixée à 128x128 pixels, le nombre de couleurs limité à 16 et la taille de la cartouche contenant le code du jeu ne peut pas dépasser 32 kilo-octets.

Mais pourquoi avoir mis ces contraintes ? N'est-ce pas gênant ? Et bien, c'est là qu'opère toute la magie de cette console.

Ses limitations stimulent la créativité !

La résolution et la taille de la carte est fixe, ce qui permet d'avoir une vision globale du nombre de niveaux que notre jeu sera capable de supporter.
La limitation de la taille de la cartouche nous force à écrire du code simple et efficace.
Le style graphique sera forcément du pixel art.
On est obligé de piocher dans les couleurs proposées, donc pas besoin de réfléchir à des palettes de couleurs.
Les sons utilisables sont également proposés, à l'instar des couleurs.

Du coup, le fait d'avoir un cadre imposé permet d'éviter de se poser trop de question sur notre jeu.

Tous les outils sont intégrés !

En effet, Pico-8 propose un éditeur de code, un éditeur de son, un éditeur de musique, un éditeur de niveaux et un éditeur de pixel art. Tout est intégré et se suffit à lui-même !

Grâce à tout ça, on peut se concentrer uniquement sur les aspects créatifs de notre jeu, comme le game design, le gameplay, le scénario, ou la musique.

Facile à prendre en main !

La cerise sur le gâteau est sa facilité de prise en main. Le combo Lua/outils intégrés permet de très vite se lancer dans la création de ton premier jeu ! La communauté est excellente et il existe de très bon tutoriels sur le net.

Favorise le partage !

Le fichier du jeu est la cartouche intégrale du jeu. Il est donc très simple de l'extraire et de la partager, que ça soit sur itch.io ou sur sur le hub Pico-8.

Parfait pour les Game Jams

Pour finir, sa facilité de prise en main et son cadre imposé le rendent parfait pour les Game Jams. De gros projets ont utilisé Pico-8 dans des Game Jams pour prototyper leur jeu, comme Celeste !

Mais non libre

Malheurseusement, l'outil est non-libre et donc payant. Je n'ai pas l'habitude de promouvoir des logiciels payants, mais celui-ci est tellement bien pensé que je pense que ça vaut réellement le coup. Si vraiment ça te bloque, tu peux te tourner vers un équivalent open source appelé TIC-80.

Mes jeux

Tu peux jeter un oeil aux jeux que j'ai codé pour des Game Jams avec Pico-8. J'ai tenté de découvrir différents styles de jeux :

Shoot The Moon, un shooter spatial donc le code source est disponible ici.

Solène Is Missing, un mini rpg donc le code source est disponible là.

Badaboom, un petit jeu d'arcade à l'ancienne basé sur une scène du film Le 5ème élément, donc le code source est disponible ici aussi.

Hellhound, le prototyope d'un jeu de plateforme et de survie, donc le code source est disponible là aussi.

Le code

Au niveau du code, tu pourras trouver de nombreuses similarités avec Löve qu'on a étudié précédemment.

Tu as aussi les trois fonctions init, update et draw dans lesquelles tout ce passe. De la même manière il te faudra gérer l'état de ton jeu et les différents écrans. Tu ne seras vraiment pas dépaysé !

Voici un exemple complet d'une cartouche, celle de Hellhound, pour te faire une idée !

pico-8 cartridge // http://www.pico-8.com
version 29
__lua__
-- hellhound
-- mobo
function _init()
    state=2
end

function _update60()
    if (state==0) update_game()
    if (state==1) update_gameover()
    if (state==2) update_gamestart()
end

function _draw()
    if (state==0) draw_game()
    if (state==1) draw_gameover()
    if (state==2) draw_gamestart()
end
-->8
-- game start
function update_gamestart()
    if (btnp(⬆️)) init_game()
end

function draw_gamestart()
    cls()
    map(0, 0, 0, 0, 128, 64)
    camera(0,384)
    rectfill(31,73+384,105,109+384,8)
    rectfill(28,70+384,102,106+384,0)
    print("Hellhound",34,76+384,8)
    print("⬆️ to start",34,96+384,8)
end
-->8
-- game over
function update_gameover()
    if (btnp(⬆️)) init_game()
    if music_start then
        music_start=false
        music(-1)
    end
end

function draw_gameover()
    cls()
    map(0, 0, 0, 0, 128, 64)
    camera(0,384)
    rectfill(31,73+384,105,109+384,8)
    rectfill(28,70+384,102,106+384,0)
    print("Game over",34,76+384,8)
    print("Score:"..ticks,34,86+384,8)
    print("⬆️ to retry",34,96+384,8)
end
-->8
--game
function init_game()
    state=0
    ticks=0
    music_start=false
    cam=create_camera(0,512-128,1,2,32)
    p=create_player(8,62*8)
    bullets=create_bullets()
    enemies=create_enemies()
    explosions=create_explosions()
    spawns={
        {x=10*8,y=62*8},{x=13*8,y=62*8},{x=6*8,y=58*8},
        {x=6*8,y=54*8}, {x=3*8,y=51*8}, {x=1*8,y=51*8},
        {x=10*8,y=56*8}, {x=12*8,y=56*8}, {x=21*8,y=56*8},
        {x=21*8,y=62*8}, {x=25*8,y=62*8}, {x=29*8,y=62*8},
        {x=27*8,y=58*8}, {x=30*8,y=58*8}, {x=29*8,y=55*8},
        {x=29*8,y=51*8}
    }
    for s in all(spawns) do
        enemies:spawn(s.x,s.y)
    end
end

function update_game()
    ticks+=1
    if not music_start then
        music(0)
        music_start=true
    end
    p:update()
    cam:update()
    bullets:update()
    enemies:update()
    explosions:update()
end

function draw_game()
    cls(7)
    palt(0, false)
    palt(15, true)
    --camera
    cam:draw()
    -- map
    map(0, 0, 0, 0, 128, 64)
    -- items
    p:draw()
    enemies:draw()
    bullets:draw()
    explosions:draw()
    -- hud
    camera(0,0)
    print('score: '..ticks,0,0,10)
    spr(16,0,120)
    for i=1,p.life do
        rectfill(0+i*8, 125, 8+i*8, 127, 10)
    end
end
-->8
-- camera
function create_camera(x,y,dx,dy,margin)
    local c={
        x=x,y=y,dx=dx,dy=dy,speed=speed,margin=margin,
        update=function(self)
            if (p.x-cam.x<(64-cam.margin)) then
                cam.x=mid(0,cam.x-cam.dx,1024-128)
            elseif (p.x-cam.x>(64+cam.margin)) then
                cam.x=mid(0,cam.x+cam.dx,1024-128)
            end
            if (p.y-cam.y<(64-cam.margin)) then
                cam.y=mid(0,cam.y-cam.dy,512-128)
            elseif (p.y-cam.y>(64+cam.margin)) then
                cam.y=mid(0,cam.y+cam.dy,512-128)
            end
        end,
        draw=function(self)
            camera(cam.x,cam.y)
        end
    }
    return c
end
-->8
-- player
function create_player(x,y)
    local p={
        x=x,y=y,w=8,h=8,dx=0,dy=0,acc=0.08,dcc=0.9,max_dx=1,max_dy=2,
        gravity=0.15,jump_speed=-1.75,jump_hold_time=0,ungrounded_time=0,max_jump_press=15,
        jump_forgiveness=10,grounded=false,is_jumping=false,flip=false,
        anims=anims(self),curanim="idle",curframe=1,animtick=0,attack_tick=0,
        life=15,
        set_anim=function(self,anim)
            if(anim==self.curanim)return--early out.
            local a=self.anims[anim]
            self.animtick=a.ticks--ticks count down.
            self.curanim=anim
            self.curframe=1
        end,
        update=function(self)
            move(self)
            jump(self)
            fall(self)
            attack(self)
            animate(self)
            hurt(self)
        end,
        draw=function(self)
            local a=self.anims[self.curanim]
            local frame=a.frames[self.curframe]
            spr(frame, self.x, self.y,1,1,self.flip)
        end
    }
    return p
end

function move(self)
    if btn(⬅️) then
        self.dx-=self.acc
        self.flip=true
        if (self.grounded) self:set_anim("run")
    elseif btn(➡️) then
        self.dx+=self.acc
        self.flip=false
        if (self.grounded) self:set_anim("run")
    else
        self.dx*=self.dcc
        if (self.grounded and self.dx>0) self:set_anim("slide")
        if (self.grounded and self.dx<=0) self:set_anim("idle")
    end
    if is_solid(self.x+self.dx,self.y) then
        self.dx=0
    end
    self.dx=mid(-self.max_dx,self.dx,self.max_dx)
    self.x+=self.dx
end

function jump(self)
    if btn(🅾️) then
        local canJump=self.grounded or (self.ungrounded_time > 0 and self.ungrounded_time <= self.jump_forgiveness) and not self.is_jumping
        if self.jump_hold_time>0 or canJump then
            if (self.jump_hold_time==1) sfx(3)
            self.is_jumping=true
            self.jump_hold_time+=1
            if self.jump_hold_time<self.max_jump_press then
                self.dy=self.jump_speed
            end
        end

    else
        self.jump_hold_time=0
    end
end

function fall(self)
    self.dy+=self.gravity
    if is_solid(self.x,self.y+self.dy) then
        self.dy=0
        self.grounded=true
        self.is_jumping = false
        self.ungrounded_time = 0
    else
        self.grounded=false
        self.ungrounded_time+=1
    end
    if(not self.grounded) self:set_anim("jump")
    self.dy=mid(-self.max_dy,self.dy,self.max_dy)
    self.y+=self.dy
end

function attack(self)
    if btn(❎) then
        if (p.attack_tick%15==0) then
            bullets:shoot()
        end
        if(self.grounded) self:set_anim("attack")
        if(not self.grounded) self:set_anim("airattack")
        p.attack_tick+=1
    else
        p.attack_tick=0
    end
end

function anims(self)
    return {
        ["idle"]={ticks=15,frames={1,2,3,4}},
        ["run"]={ticks=5,frames={5,6}},
        ["jump"]={ticks=1,frames={10}},
        ["slide"]={ticks=1,frames={1}},
        ["attack"]={ticks=1,frames={7}},
        ["airattack"]={ticks=1,frames={11}},
        ["climb"]={ticks=10,frames={8,9}},
    }
end

function hurt(self)
    if ticks%35==0 then
        p.life-=1
    end
    --death
    if p.life<=0 then
        sfx(2)
        state=1
    end
end
-->8
-- bullets
function create_bullets()
    return {
        items={},
        update=function(self)
            for b in all(self.items) do
                b.x+=b.speed
                animate(b)
                if b.x<0 or b.x>1024 or is_solid(b.x,b.y) then
                    del(self.items,b)
                end
            end
        end,
        draw=function(self)
            for b in all(self.items) do
                local a=b.anims[b.curanim]
                local frame=a.frames[b.curframe]
                spr(frame,b.x,b.y,1,1,b.flip)
            end
        end,
        shoot=function(self)
            sfx(1)
            local new_bullet={
                x=p.flip and p.x-4 or p.x+4,
                y=p.y,
                speed=p.flip and -1.5 or 1.5,
                flip=p.flip,
                anims={["shoot"]={ticks=5,frames={12,13,14,15}}},
                curanim="shoot",curframe=1,animtick=0
            }
            add(self.items, new_bullet)
        end
    }
end
-->8
-- enemies
function create_enemies()
    return {
        items={},
        update=function(self)
            for e in all(self.items) do
                if (not e.flip) e.x+=e.speed
                if (e.flip) e.x-=e.speed
                animate(e)
                if is_solid(e.x,e.y) or not is_solid(e.x,e.y+8) then
                    e.flip=not e.flip
                end
                -- killed ?
                for b in all(bullets.items) do
                    if collide(e,b) then
                        explosions:add(b.x+4,b.y+2)
                        del(bullets.items,b)
                        e.life-=1
                        if e.life==0 then
                            if (p.life<15) p.life+=1
                            sfx(0)
                            del(enemies.items,e)
                            local random_spawn=rnd(spawns)
                            enemies:spawn(random_spawn.x,random_spawn.y)
                        end
                    end
                end
            end
        end,
        draw=function(self)
            for e in all(self.items) do
                local a=e.anims[e.curanim]
                local frame=a.frames[e.curframe]
                spr(frame,e.x,e.y,1,1,e.flip)
            end
        end,
        spawn=function(self,x,y)
            local new_enemy={
                x=x,
                y=y,
                speed=1,
                life=1,
                flip=false,
                anims={["run"]={ticks=5,frames=rnd{{17,18},{33,34},{49,50},{19,20},{35,36}}}},
                curanim="run",curframe=1,animtick=0
            }
            add(self.items, new_enemy)
        end
    }
end
-->8
--explosions
function create_explosions(x,y)
    return {
        items={},
        update=function(self)
            for e in all(self.items) do
                e.timer+=1
                if e.timer==13 then
                    del(self.items,e)
                end
            end
        end,
        draw=function(self)
            for e in all(self.items) do
                circ(e.x,e.y,e.timer/3,
                8+e.timer%3)
            end
        end,
        add=function(self,x,y)
            add(self.items,{x=x,y=y,timer=0})
        end
    }
end
-->8
-- misc
function is_solid(x, y, flag)
    flag = flag or 0
    if(fget(mget(flr(x/8),flr(y/8)),flag))return true
    if(fget(mget(flr((x+7)/8),flr(y/8)),flag))return true
    if(fget(mget(flr(x/8),flr((y+7)/8)),flag))return true
    if(fget(mget(flr((x+7)/8),flr((y+7)/8)),flag))return true
    return false
end

function collide(a,b)
    return not (a.x>b.x+8
        or a.y>b.y+8
        or a.x+8<b.x
        or a.y+8<b.y)
end

function animate(self)
    self.animtick-=1
    if self.animtick<=0 then
        self.curframe+=1
        local a=self.anims[self.curanim]
        self.animtick=a.ticks
        if self.curframe>#a.frames then
            self.curframe=1
        end
    end
end


__gfx__
00000000ffff8ff8ffffffffffff8ff8ffffffffffff8ff8ffff8ff8ffff8ff8f8080000f8080000ffff8ff8ffff8ff8ffffffffffffffffffffffffffffffff
00000000ffff0000ffff8ff8ffff0000ffff8ff8ffff0000ffff0000ffff0000ff000000ff000000ffff0000ffff0000fff2222ffff2222ffff2222ffff2222f
00700700ff000808ff000000ff000808ff000000ff000808ff000808ff000808ff080000ff080000ff000808ff000808ff288882ff228882ff222882ff228882
00077000f0000000f0000808f0000000f0000808f0000000f0000000f0000000f8000000f8000000f0000000f0000000f2899aa8f22899a8f2228998f22899a8
00077000f0000000f0000000f0000787f0000000f0000000f0000000f0000787fff00000fff00000f0000000f00007872899aaa822899aa8222899a822899aa8
0070070000000000f000000000000888f0000787000000000000000000000888fff00000fff000000000000000000888f2899aa8f22899a8f2228998f22899a8
00000000f000000000000000f000000000000888f0000000f0000000f0000000ffff0000ffff0000f0000000f0000000ff288882ff228882ff222882ff228882
00000000ff0f0ff0ff0f0ff0ff0f0ff0ff0f0ff0ff0f0ff0f0f0ff0fff0f0ff0ffffff0ffffffff0fffffffffffffffffff2222ffff2222ffff2222ffff2222f
ffffffffff444444ff444444ff333333ff3333330000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
fffffffff44eeeeef44eeeeef33eeeeef33eeeee0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
fffffffff4eee1e1f4eee1e1f3eee1e1f3eee1e10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
faafaafff44eeeeef44eee8ef33eeeeef33eee8e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
faaa7afff44eeeeef44eee8ef33eeeeef33eee8e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
faaaaafff3333333fe33333ef5555555fe55555e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
ffaaaffffe33333ef3333333fe55555ef55555550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
fffaffffffeefeeffffeefeeffeefeeffffeefee0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000ff999999ff999999ff888888ff8888880000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000f99eeeeef99eeeeef88eeeeef88eeeee0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000f9eee1e1f9eee1e1f8eee1e1f8eee1e10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000f99eeeeef99eee8ef88eeeeef88eee8e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000f99eeeeef99eee8ef88eeeeef88eee8e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000f4444444fe44444efcccccccfeccccce0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000fe44444ef4444444fecccccefccccccc0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000ffeefeeffffeefeeffeefeeffffeefee0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000ff555555ff55555500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000f55eeeeef55eeeee00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000f5eee1e1f5eee1e100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000f55eeeeef55eee8e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000f55eeeeef55eee8e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000f9999999fe99999e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000fe99999ef999999900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000ffeefeeffffeefee00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
55555555000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000882222222222288200000000
55555555000002200200022002000000000200200220020000200000000001100100011001000000000100100110010000100000828822222228828200000000
55555555002200000002022000000200000002200220022000002200001100000001011000000100000001100110011000001100282882222288282200000000
55555555002200000000000000000000000000000000000000002200001100000000000000000000000000000000000000001100282288222882282200000000
55555555000000002020202020202020202020202020202000000000000000001010101010101010101010101010101000000000228228828822822200000000
55555555020000222222222222222222222222222222222222000020010000111111111111111111111111111111111111000010228222282222822200000000
55555555000002222822228888222282222228822288282222200020000001111c1111cccc1111c111111cc111cc1c1111100010222828828828222200000000
5555555500000222882882882828288222882882828828822220000000000111cc1cc1cc1c1c1cc111cc1cc1c1cc1cc111100000228882222288822200000000
00000000000002882222222222222222222222222222222222220000000001cc1111111111111111111111111111111111110000288282222282882200000000
000000000220228822eee22222666662222222222266652222200000011011cc11ddd11111666661111111111166651111100000888888888888888200000000
00000000022002222ee8ee2226666666222222222660665282220000011001111dd8dd11166666661111111116606651c1110000222282222282222200000000
0000000000002228ee898ee2260060062222222266606665822000200000111cdd898dd1160060061111111166606665c1100010222228222822222200000000
0000000000200228e89a98e2266060662222222266000665222200000010011cd89a98d116606066111111116600066511110000222228222822222200000000
00000000000022222e444e2222666662622226226660666588200200000011111d444d11116666616111161166606665cc100100222222828222222200000000
000000000200028822e4e22222626262266662226666666588220220010001cc11d4d111116161611666611166666665cc110110222222828222222200000000
000000000000222822242222222222226222262266666665222000000000111c1114111111111111611116116666666511100000222222282222222200000000
222222220000022222222222222222222222222222222222822200000000011111111111111111111111111111111111c1110000cc11111111111cc100000000
22222222000022882222222222222222222222222222222222200220000011cc1111111111111111111111111111111111100110c1cc1111111cc1c100000000
222222220020022822222222222222222222222222222222882202200010011c11111111111111111111111111111111cc1101101c1cc11111cc1c1100000000
222222220000222222222222222222222222222222222222882000000000111111111111111111111111111111111111cc1000001c11cc111cc11c1100000000
222222220000022822222222222222222222222222222222222200000000011c111111111111111111111111111111111111000011c11cc1cc11c11100000000
222222220000222222222222222222222222222222222222882002200000111111111111111111111111111111111111cc10011011c1111c1111c11100000000
22222222020002882222222222222222222222222222222282220200010001cc11111111111111111111111111111111c1110100111c1cc1cc1c111100000000
22222222000022822222222222222222222222222222222222200000000011c1111111111111111111111111111111111110000011ccc11111ccc11100000000
1111111100000222882882882882828228828822288288282220000000000111cc1cc1cc1cc1c1c11cc1cc111cc1cc1c111000001cc1c11111c1cc1100000000
1111111102000222882222822822228828822222228288222220000001000111cc1111c11c1111cc1cc1111111c1cc1111100000ccccccccccccccc100000000
111111110200002222222222222222222222222222222222220000200100001111111111111111111111111111111111110000101111c11111c1111100000000
1111111100000000020202020202020202020202020202020000000000000000010101010101010101010101010101010000000011111c111c11111100000000
1111111100220000000000000000000000000000000000000000220000110000000000000000000000000000000000000000110011111c111c11111100000000
11111111002200000220200000200000022000000220022000002200001100000110100000100000011000000110011000001100111111c1c111111100000000
11111111000002000220002000000020020020000020022002200000000001000110001000000010010010000010011001100000111111c1c111111100000000
111111110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111c1111111100000000
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040404040004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004040404040000000000000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000040400040000000000000000000000000000000000000000000000000000000000000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000040404040000000000000000000000000000000000000004040404000404040004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000004040404040000040000000000000000000000000000000000000000000000000000000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000040404040400040000040400000000000000000000000000000000000404040400000000000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000040000000400000000000000000000000000000000000000000000000000000404
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000404040400000004040004040400000000000000040000000404000000000000000000000000000000000000000004040400040004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000040000000004040400000000000000000000000000000000000000000000000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000404040404040000000000000404040400000000000000000000000000000000040400000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000040404040400000000000000000000000000000000040000000000000000000404000000000000000000000004040404040000000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000040000000000000000000004040400000000000000000000000000000000000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000404040400040000040000000000000000000000000404000000000000000000040404040400000004
05050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050504
00000000000404040400000004040400000000000000000000000000040000040000000000000000000000000000040404000000000000000000000000000004
1424543444543424342434543444246405057484b494a48494a484b48494a4c40505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000040404000000000000000000000000040000000000000000000000000000000004040000000000000000000404040004
16060606060606060606060606d4e465050576d6e607070707070707070707c50505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000040400000000000000000000040000000000000000000000000000000000000400000000000000000000000004
15062506060606060606060606d5e566050576d7e707070707070707078507c50505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000404000000000000000404040404
16350606060606060606060606060666050576070707070707070707070795c50505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000040000000000000000000000040000000000000000000000000000000000040400000000000000000000000004
16572757470606060606060606060665050576070707070707070707079797c60505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000040404040004040400000000040000000000000000000000000000000404000000000000000000000004040404
15060606160606060606060606060666050575070707070707b50707070707c50505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000004040000000000000000000000000000000004
15060606163506060606060606060665050576070707070787b7a707070707c60505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000404000000000000000000000000000000000004
160606061737373706060606060606665494750785070707070707070707a5c60505050505050505050505050505050505050505050505050505050505050504
00000404040400000000000000000000000000000000000404040404000000040000000000000000000004040400000000000000000000000000040404000004
15060606060606060606060606550606450707070707070707070707a7b7a7c60505050505050505050505050505050505050505050505050505050505050504
00000000000404000000000000000000000000000000040400000000000000040000000000000000000404000000000000000000000000000000000000000004
160606060606060606063737373737663797769797a7a70707070707070707c50505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000040000000000000000040400000000000000000000000000000000000000000004
160606060606060606060606060606650505750707070707070707070795a5c50505050505050505050505050505050505050505050505050505050505050504
00000000000404040404040000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000004040404
1506060606064747570606060606066505057507070707070707a7a7b787a7c50505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000404040404000000000000040000000000000000000000000000000000000000000000000000000004000004
16060606060666060606060625060666050576070707070707070707070707c60505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000040404040404000000000000000000000000040000000000000000000000000000000000000000000000000000040404040404
15060606273767060637060606060665050576070707b7a707070707078507c60505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000004040400040000000000000000000000000000000000000000000000000000040000000004
150606576745060606060606060635660505750707079507070707070707b5c50505050505050505050505050505050505050505050505050505050505050504
00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000040000000004
1727374757273747273727374757476705057787a787a7b797879787a797b7c70505050505050505050505050505050505050505050505050505050505050504
04040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404
__gff__
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001010101010101010101010101000000000100000000010100000000010000000001000000000101000000000100000000010101010101010101010101000000
0000000000000000000001010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
__map__
4040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000040404000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000040404000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000004040004000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000404000004040404000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000040400000004000404040000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000004040400000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000004040000000004000000040400000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000404000000000004000000000004040000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000040404000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000040400000000000004000000000000040000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000004040000000000000004000000000000000404000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4040404040404040404040000040404040404040404040404040404040404040000000000000000000000000000000000000000000004000000000000000004000000000000000004040000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000404000000000000000004000000000000000000040000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000004040400000000000000000000000000000000040000000000000000000000000000000000000000000400000000000000000004000000000000000000000400000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000040400000000000000000004000000000000000000000404000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000040404040400000000000000000000000000000000040000000000000000000000000000000000000004040000000000000000000004000000000000000000000004040000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000404040400000000000000000000000000040000000000000000000000000000000000040404000000000000000000000004000000000000000000000000040000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000404000000000000000000000000040000000000000000000000000000000004040000000000000000000000000004000000000000000000000000000400000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000040400000000000000000000000000000004000000000000000000000000000004000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000040000000000000000000000000404040000000000000000000000000000000004000000000000000000000000000004040000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000404040404040000000000000000040000000000000000000000040400000000000000000000000000000000000004000000000000000000000000000000000400000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000400000000000000000000000000040000000000000000000404040000000000000000000000000000000000000004000000000000000000000000000000000004040000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000404040400000000000000000000000000040000000000000004040400000000000000000000000000000000000000000004000000000000000000000000000000000000040400000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000400000000000000000000000000000000040000000000000004000000000000000000000000000000000000000000000004000000000000000000000000000000000000000404000000000000000000000400000000000000000000000000000000000000000000000000000000000000040
4000000000000000004040404040400000000000000000000000000000000000000000000000404000000000000000000000000000000000000000000000004000000000000000000000000000000000000000004040000000000000000000000000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000040400000000000000000000000000000000000000000000000000000000000000000000000000000000040
4000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000404000000000000000000000000000000000000000000000000000000000000000000000000000000040
4040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040404040000000000000000000404040
__sfx__
00010000160001602016030160401705016050160501605016050150501305012050100500e0500c0500a05008050060400302000010000000000000000000000000000000000000000000000000000000000000
000100002e7102d7302d7502d7502d7502d7502c7502b7502b7502a7502775024750227501f75016750117500d750087500675005740057400473003720027100271000700007000070000700007000070000700
000300000d1200a140091500915009150091500815007150051500415003150021500115000150001500015000150001500015000150001500015000150001500015000140001200011000110001100011000110
0101000011320123201332015320163201a3201b3201e320213202232026320293202c3202e320333203432035320003000030000300003000030000300003000030000300003000030000300003000030000300
001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
010f00000003100001000310000100001000010000100001000310000100031000010000100001000010000100031000010003100001000010000100001000010000100001000010000100001000010000100001
__music__
02 0a424344

Plutôt simple et efficace non ?

Amuse-toi bien et sois créatif !

Créer un petit jeu de plateforme avec Löve

2021-03-19T00:00:00+01:00

On fait suite au précédent article du blog qui introduisait le développement de jeux vidéo en Lua avec Löve. Tu vas voir comment créer un petit jeu de plateforme inspiré de Super Meat Boy et de Disc Room uniquement avec Löve.

Disc Room Escape

Le jeu s'appelle Disc Room Escape et est jouable sur itch.io. Le but est simplement de traverser les différents niveaux, sans mourir, dans la limite de temps disponible. Il faudra sauter sur des plateformes et éviter des scies mortelles.

Ici, pas besoin de librairies et outils annexes. Tout sera fait uniquement avec Löve.

Code source

Le code source est intégralement disponible sur Github. N'hésite pas à le récupérer, à jouer avec, à le modifier et à te l'approprier.

Je vais t'expliquer dans les grandes lignes son fonctionnement. Suis les liens vers les fichiers sources pour les comprendre. Sur cet article, je ne mettrais en exemple que certains bouts de code intéressants pour éviter de trop le surcharger d'information.

Etat du jeu

On va commencer par créer un système qui gère l'état de notre jeu. Dans les prochains fichiers, on va beaucoup utiliser setmetatable, qui permet de gérer des sortes de classes en Lua.

Tu voudras avoir un écran d'accueil où tu lances le jeu, un écran avec le jeu en cours, un écran de fin lors de la victoire et un écran de fin lors de la défaite. Ces écrans vont utiliser les fonctions update et draw de Löve pour se mettre à jour, afficher les éléments et gérer les touches.

function mt:update(dt)
    if love.keyboard.isDown('return') or (Joystick and Joystick:isGamepadDown('start')) then
        GameState.setCurrent('Play', GAME_LEVEL_START)
        local doorSound = love.audio.newSource(SOUND_DOOR, "static")
        doorSound:play()
    end
end

function mt:draw()
    love.graphics.setNewFont(12)
    love.graphics.setColor(1, 1, 1, 1)
    love.graphics.setBackgroundColor( 104/255, 124/255, 133/255 )
    love.graphics.draw(self.img, 70, 0, 0, 0.4, 0.4)
    love.graphics.print({{0,0,0,1}, 'Press [enter] or [start] to start the game !'}, 75, 220)
end

Tous ces écrans vont être manipulables grâce à une classe GameState qui va se charger de gérer la transition des états. Il suffit par exemple, d'utiliser la commande suivante pour changer de niveau :

GameState.setCurrent('Play', self.level_num + 1)

Le fichier principal de Löve va juste se charger de démarrer le jeu sur l'écran d'accueil et d'initier le joystick, le fichier de configuration et les constantes du jeu.

Animation et assets

Tous les assets du jeu, sons et images, sont disponibles ici. Tu peux les modifier selon tes propres envies. Tu auras besoin de deux petits helpers, un pour gérer les animations et un autre pour gérer les assets.

Le monde

Chaque élément du jeu sera ajouté à un monde, qui va se charger de vérifier en continue la position des éléments et leurs collisions.

On vérifie la collision de nos éléments à l'aide d'une fonction toute simple :

local function checkCollision(a, b)
    return a.x < b.x + b.w and
        a.x + a.w > b.x and
        a.y < b.y + b.h and
        a.h + a.y > b.y
end

Les niveaux

Les niveaux seront représentés par des tableaux de la manière suivante :

return {
    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
    10,0,0,0,0,0,0,0,0,3,3,0,0,0,3,3,0,0,0,0,0,0,0,0,10,
    10,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,10,
    2,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,
    1,1,1,1,1,1,1,5,5,5,5,5,5,5,5,5,5,5,1,1,1,1,1,1,1,
}

Chaque chiffre va représenter un élément sur notre écran.

le 0 représente le vide.
le 1 sera des murs.
le 2 sera le sol.
le 3 sera des plateformes amovibles.
le 4 sera les portes de sorties.
le 5 sera des scies fixes.
le 6 sera le toît.
le 7 sera le boss du jeu.
le 8 sera les ennemies du jeu, des scies qui se déplacent.
le 9 sera notre héro.
le 10 sera un élement du décor, l'échafaudage.

Chacun de ces éléments utilise le système de classes de Lua via setmetatable pour sa représentation. Une classe Level va se charger de l'affichage des éléments du niveau en fonction de ces chiffres.

Il sera alors possible de déclencher des évenements dans le monde via une fonction trigger, par exemple lorsque le joueur franchit une porte.

Pour gérer cet évenement, dans notre classe Door on a :

function mt:update(dt)
    self.touches_hero = GameState.getCurrent().world:check(self, 'is_hero')
end

function mt:draw()
    assets.qdraw(7, self.x, self.y)
    if self.touches_hero then
        GameState.getCurrent():trigger('door:open')
    end
end

Et dans l'état du jeu en cours PlayState on a :

function mt:trigger(event, actor, data)
    if event == 'door:open' then
        local doorSound = love.audio.newSource(SOUND_DOOR, "static")
        doorSound:play()
        if self.level_num < GAME_LEVEL_MAX then
            GameState.setCurrent('Play', self.level_num + 1)
        else
            GameState.setCurrent('Win')
        end
    end
end

Le hero

Notre hero va devoir se déplacer si on utilise le joystick ou le clavier, en utilisant un système d'accélération et de décélération dans son update :

local dx, dy = 0, 0

if love.keyboard.isDown('left') or (Joystick and (Joystick:isGamepadDown('dpleft') or Joystick:getGamepadAxis('leftx') <= -0.25)) then
    self:setAnim('run')
    self.last_direction = -1
    -- acceleration system
    self.vx = self.vx + (-self.speed * self.acceleration * dt)
    if self.vx < -self.speed then self.vx = -self.speed end
elseif love.keyboard.isDown('right') or (Joystick and (Joystick:isGamepadDown('dpright') or Joystick:getGamepadAxis('leftx') >= 0.25)) then
    self:setAnim('run')
    self.last_direction = 1
    -- acceleration system
    self.vx = self.vx + (self.speed * self.acceleration * dt)
    if self.vx > self.speed then self.vx = self.speed end
else
    -- deceleration system
    if self.vx < 0 then
        self.vx = self.vx + (self.speed * self.deceleration * dt)
        if self.vx > 0 then self.vx = 0 end
    elseif self.vx > 0 then
        self.vx = self.vx + (-self.speed * self.deceleration * dt)
        if self.vx < 0 then self.vx = 0 end
    end
end
dx = dx + self.vx * dt

Tu va devoir gérer la gravité lors du saut dans le update également :

if (love.keyboard.isDown('up') or (Joystick and (Joystick:isGamepadDown('a')))) then
    -- init jump
    if self:canJump() then
        self.vy = HERO_JUMP_SPEED
        self.is_jumping = true
        local jumpSound = love.audio.newSource(SOUND_JUMP, "static")
        jumpSound:play()
    -- during the jump
    elseif self.is_jumping == true then
        -- reduce the gravity for smooth jump
        if self.vy < 0 then
            self.vy = self.vy - HERO_JUMP_GRAVITY * dt
        end
    end
end
-- gravity
if self:isGrounded() then
    self.vy = 0
    self.is_jumping = false
    self.ungroundedTime = 0
else
    self:setAnim('jump')
    self.vy = math.min(self.vy + HERO_GRAVITY * dt, HERO_MAX_VELOCITY)
    self.ungroundedTime = self.ungroundedTime + dt
end

Et bien évidemment, il faudra l'animer à l'aide de notre helper :

self:setAnim('run')

et enfin le déplacer dans notre monde via :

GameState.getCurrent().world:move(self, self.x + dx, self.y + self.vy, 'is_solid')

Les particules de sang

Enfin, à la mort, on va utiliser un système de particules pour gérer le sang. On va pouvoir utiliser différents paramètres pour styliser nos particules :

p.psystem:setParticleLifetime(0.5, 3)
p.psystem:setEmissionRate(128)
p.psystem:setEmitterLifetime(0.5)
p.psystem:setSizeVariation(1)
p.psystem:setLinearAcceleration(-100, -100, 100, 100)
p.psystem:setColors(1, 1, 1, 1, 1, 1, 1, 0)

Conclusion

J'espère que cet aperçu va te donner envie d'essayer Löve plus en profondeur !

Ici, on a tout fait à la main, sans librairie. C'est la meilleur manière de procéder je pense pour avoir le contrôle complet de ton code.

Mais si tu veux voir ce que ça donne en utilisant des librairies de gestion de collisions comme Bump, des utilitaires pour gérer l'état du jeu ou la caméra comme Hump, l'outil de gestion des animations Anim8, ou encore l'utilitaire STI pour manipuler des niveaux créés avec Tiled, tu peux jeter un oeil à mon deuxième projet Löve, The Legend Of Shifu, dont l'intégralité du code source est disponible sur Github. C'est un petit jeu inspiré de The Binding Of Isaac.

Have fun !

Débuter le développement de jeux vidéo en créant un Infinite Runner en Lua

2021-03-16T00:00:00+01:00

L'an dernier, principalement pendant la période de confinement, je me suis mis dans l'idée d'expérimenter le développement de jeux vidéo. C'est un domaine qui m'a toujours attiré et passionné depuis tout petit, mais je n'ai jamais vraiment pris le temps de m'y attarder sérieusement.

Les moteurs de jeux actuels comme l'Unreal Engine ou Unity ne m'attiraient pas vraiment. Ils me donnaient l'impression de devoir apprendre à utiliser un logiciel de création complexe plutôt que de développer simplement un jeu.

L'idée était de rester au plus simple, au plus rapide et au plus prêt du code. Et donc de pouvoir utiliser le combo Linux + VS Code pour le développement.

Afin de trouver un moteur de jeu qui convenait à mes attentes, je me suis intéressé à l'excellent site Itch.io, qui permet aux développeurs indépendants de vendre leurs créations et de participer à des Game Jams. Pour mes lecteurs musiciens, c'est un peu le Bandcamp des jeux vidéo.

Et ce qui est intéressant, c'est qu'il propose une liste des moteurs de jeux les plus utilisés sur sa plateforme. En éliminant les logiciels de création (Unity, Construct, Game Maker, Unreal Engine, Godot), il nous reste principalement deux moteurs de jeux :

LÖVE et PICO-8

Ces deux moteurs sont vraiment excellents et on l'avantage d'être basé sur le même langage de programmation, Lua.

Lua

Lua est un langage de script écrit en C très simple à apprendre et à utiliser. Il permet de faire de la programmation impérative de base, et se situe donc à mi-chemin entre Python, Go et Shellscript. Il ne faut pas espérer y trouver des concepts très avancés en programmation objet ou fonctionnel.

Néanmoins, il est parfait pour s'initier au développement de jeux vidéo sans avoir de grandes connaissances en programmation en amont.

Ses concepts de base sont bien résumés sur Learn Lua in Y Minutes et ça ressemble à ça :

-- defines a factorial function
function fact (n)
    if n == 0 then
        return 1
    else
        return n * fact(n-1)
    end
end

print("enter a number:")
a = io.read("*number")        -- read a number
print(fact(a))

Prends-toi 10 minutes pour te familiariser avec le langage et on peut passer à la suite !

LÖVE

On commence par le moteur LÖVE, qui est un moteur open source, à l'inverse de PICO-8 qui est payant et propriétaire. Tu l'installes et tu fais le Getting Started du site officiel qui va te permettre que vérifier que tout est ok.

Tout le fonctionnement de LÖVE se situe autour de 3 fonctions principales.

La fonction load permet d'initialiser les éléments du jeu une fois au démarrage, comme le chargement d'images ou l'initialisation de variables. Dans l'exemple ci-dessous, on charge une image et on définit la police de caractères et les couleurs de notre jeu :

function love.load()
    image = love.graphics.newImage("cake.jpg")
    love.graphics.setNewFont(12)
    love.graphics.setColor(0,0,0)
    love.graphics.setBackgroundColor(255,255,255)
end

La fonction update est appelée continuellement, comme une boucle infinie, et utilise le delta time en paramètre qui représente le temps écoulé entre chaque appel. C'est ici que l'on va mettre à jour les données de notre jeu. Tu vas pouvoir l'utiliser pour mettre à jour les positions X et Y de ton joueur en fonction de l'appuie sur une touche par exemple. Ici, on incrémente un nombre lorsque l'on appuie sur flèche haut :

function love.update(dt)
    if love.keyboard.isDown("up") then
        num = num + 100 * dt -- this would increment num by 100 per second
    end
end

La fonction draw gère l'affichage des éléments, et les met automatiquement à jour lorsque des modifications sont apportées sur la position du joueur dans update par exemple. La séparation de update et de draw permet d'éviter des soucis de performances. Si des méthodes de calculs prennent beaucoup de temps dans update, ça n'affecte pas l'affichage des éléments dans draw et évite des effets de ralentissements. Ici, on affiche une image en fonction de sa position et du texte.

function love.draw()
    love.graphics.draw(image, imgx, imgy)
    love.graphics.print("Click and drag the cake around or use the arrow keys", 10, 10)
end

Outils

Avant de s'attaquer au développement de ton premier jeu, il faut t'équiper de certains outils.

Pixel Art

Pour l'instant, on ne s'intéressera qu'aux dessins sous forme de Pixel Art. Tu peux utiliser les outils suivants :

Piskel : Outil en ligne pour faire tes dessins et animations. Parfait pour débuter.
Krita : Outil de dessin très populaire sous Linux, qui permet d'utiliser une brosse spécifique pour le Pixel Art.
Aseprite : Mon outil préféré, mais payant pour avoir un installateur. Il est néanmoins open source et peut être compilé gratuitement depuis les sources sur Github.

Musique

Au niveau du son, tu peux t'équiper des outils suivants :

Freesound : Librarie en ligne de milliers de sons utilisable gratuitement. Parfait pour trouver des musiques et des effets.
Audacity : Outil d'édition de fichier audio, simple et efficace si tu as besoin de faire des retouches ou d'enregistrer des sons.
Jfxr : Successeur de Bfxr, c'est un outil qui permet de générer aléatoirement des sons 8bits comme le saut, le tir au laser et autres.

Editeur de cartes

On ne l'utilisera pas tout suite, mais le meilleur outil pour éditer des niveaux est Tiled. Il est gratuit, très populaire et est compatible avec la plupart des moteurs de jeux. Tu peux déjà y jeter un oeil si ça t'intéresse.

Runner

Ma première expérience dans l'utilisation de LÖVE a été la création de ce petit Infinite Runner appelé Multipla Adventure. Il s'agissait d'un projet inspiré par la destruction du carter d'huile ma Fiat Multipla sur un rocher dans un chemin forestier !

L'intégralité du code source du jeu est disponible ici. Tu peux récupérer le dossier images et sounds, où utiliser les outils cités plus haut pour faire tes propres créations ! N'hésite pas à prendre du temps pour comprendre les différents fichiers du jeu.

On va avoir besoin de quelques petites fonctions utilitaires pour gérer les animations et les collisions. Dans un fichier utils.lua, tu mets :

function newAnimation(image, width, height, duration)
    local animation = {}
    animation.spriteSheet = image;
    animation.quads = {};

    for y = 0, image:getHeight() - height, height do
        for x = 0, image:getWidth() - width, width do
            table.insert(animation.quads, love.graphics.newQuad(x, y, width, height, image:getDimensions()))
        end
    end

    animation.duration = duration or 1
    animation.currentTime = 0

    return animation
end

function setScale()
    local scale = love.graphics.getWidth() / WIN_WIDTH
    local scaleY = love.graphics.getHeight() / WIN_HEIGHT
    if scaleY < scale then scale = scaleY end
    love.graphics.scale(scale)
end

function collideRect(rect1, rect2)
    if rect1.x < rect2.x + rect2.width and
    rect1.x + rect1.width > rect2.x and
    rect1.y < rect2.y + rect2.height and
    rect1.height + rect1.y > rect2.y then
        return true
    end
    return false
end

Notre joueur sera donc une voiture qui restera fixe à gauche de l'écran. La voiture pourra sauter avec la barre d'espace ou en appuyant sur l'écran de notre smartphone android. Ce qui signifie qu'il faudra gérer la gravité à minima. Il faudra également gérer l'animation et les sons de la voiture.

Tu crées donc un fichier player.lua comme ci-dessous :

local player = {}
player.width = 48
player.height = 48
player.x = 72
player.y = WIN_HEIGHT-player.height-20
player.speedY = 0
player.gravity = -500
player.jumpHeight = -250
player.groundY = WIN_HEIGHT-48-20
player.alive = false


function loadPlayer()
    player.img = love.graphics.newImage("images/car.png")
    player.img:setFilter("nearest","nearest")
    player.anim = newAnimation(player.img, player.width, player.height, 0)
    player.jumpSound = love.audio.newSource("sounds/340629__mickyman5000__chainsaw-stop .wav", "static")
    return player
end

function updatePlayer(dt)
    player.anim.currentTime = player.anim.currentTime + dt*10

    -- android touch
    local touches = love.touch.getTouches()
    for _, touch in ipairs(touches) do
        local tx, ty = love.touch.getPosition(touch)
        if player.speedY == 0 then
            player.speedY = player.jumpHeight
        end
    end
    -- keyboard
    if love.keyboard.isDown('space') then
        if player.speedY == 0 then
            player.jumpSound:play()
            player.speedY = player.jumpHeight
        end
    end
    -- jumping
    if player.speedY ~= 0 then
        player.y = player.y + player.speedY * dt
        player.speedY = player.speedY - player.gravity * dt
    end
    -- stop jumping
    if player.y > player.groundY then
        player.speedY = 0
        player.y = player.groundY
    end
end

function drawPlayer()
    local spriteNum = math.floor(player.anim.currentTime % #player.anim.quads) + 1
    love.graphics.draw(player.anim.spriteSheet, player.anim.quads[spriteNum], player.x, player.y, 0, 1)
end

function resetPlayer()
    player.x = 72
    player.y = WIN_HEIGHT-player.height-20
    player.alive = true
    player.speedY = 0
end

La voiture restant fixe, c'est le décor qui va bouger pour donner une impression de mouvement. Pour donner du relief, on va créer 3 strates de montagnes et les faire défiler à des vitesses différentes.

Tu crées un fichier landscape.lua comme qui suit :

local imgMoutainsBack
local moutainsBackX = 0
local imgMoutainsFront
local moutainsFrontX = 0
local imgTrees
local treesX = 0
local ground

moutainsBack = love.graphics.newQuad(0,0,WIN_WIDTH,WIN_HEIGHT,WIN_WIDTH,WIN_HEIGHT)
moutainsFront = love.graphics.newQuad(0,0,WIN_WIDTH,WIN_HEIGHT,WIN_WIDTH,WIN_HEIGHT)
trees = love.graphics.newQuad(0,0,WIN_WIDTH,WIN_HEIGHT,WIN_WIDTH,WIN_HEIGHT)
ground = love.graphics.newQuad(0,0,WIN_WIDTH,WIN_HEIGHT,WIN_WIDTH,WIN_HEIGHT)

function loadLandscape()
    imgMoutainsBack = love.graphics.newImage("images/mountains_back.png")
    imgMoutainsBack:setFilter("nearest","nearest")

    imgMoutainsFront = love.graphics.newImage("images/mountains_front.png")
    imgMoutainsFront:setFilter("nearest","nearest")

    imgTrees = love.graphics.newImage("images/trees.png")
    imgTrees:setFilter("nearest","nearest")

    imgGround = love.graphics.newImage("images/ground.png")
    imgGround:setFilter("nearest","nearest")
end

function updateLandscape(dt)
    moutainsBackX = (moutainsBackX + 30*dt) % WIN_WIDTH
    moutainsFrontX = (moutainsFrontX + 60*dt) % WIN_WIDTH
    treesX = (treesX + 180*dt) % WIN_WIDTH
end

function drawLandscape()
    love.graphics.draw(imgMoutainsBack,moutainsBack,0-moutainsBackX,0)
    love.graphics.draw(imgMoutainsBack,moutainsBack,WIN_WIDTH-moutainsBackX,0)

    love.graphics.draw(imgMoutainsFront,moutainsFront,0-moutainsFrontX,0)
    love.graphics.draw(imgMoutainsFront,moutainsFront,WIN_WIDTH-moutainsFrontX,0)

    love.graphics.draw(imgTrees,trees,0-treesX,0)
    love.graphics.draw(imgTrees,trees,WIN_WIDTH-treesX,0)

    love.graphics.draw(imgGround,ground, 0, 0)
end

Enfin, on va gérer l'apparition aléatoire de notre rocher se déplacant à des vitesses différentes, que le joueur devra éviter. Dans un fichier enemy.lua, tu écris :

local enemy = {}
enemy.width = 36
enemy.height = 36
enemy.groundY = 20
enemy.x = WIN_WIDTH
enemy.y = WIN_HEIGHT-enemy.height-enemy.groundY
enemy.speedX = 200
enemy.extraX = 200
enemy.speedXMin = 200
enemy.speedXMax = 700


function loadEnemy()
    enemy.quad = love.graphics.newQuad(0,0,enemy.width,enemy.height,enemy.width,enemy.height)
    enemy.img = love.graphics.newImage("images/enemy1.png")
    enemy.img:setFilter("nearest","nearest")
    return enemy
end

function updateEnemy(dt)
    if enemy.x > WIN_WIDTH then
        enemy.speedX = math.random(enemy.speedXMin, enemy.speedXMax)
    end
    enemy.x = (enemy.x - enemy.speedX*dt) % (WIN_WIDTH + enemy.extraX)
end

function drawEnemy()
    love.graphics.draw(enemy.img,enemy.quad,enemy.x,enemy.y)
end

function resetEnemy()
    enemy.x = WIN_WIDTH
    enemy.y = WIN_HEIGHT-enemy.height-enemy.groundY
end

Il ne reste plus qu'à inclure tous ces éléments dans LÖVE !

Pour ce faire, tu crées un fichier de constantes const.lua pour définir la taille de la fenêtre et le titre du jeu :

TITLE = "Game 1"
PATH_ICON = "images/enemy1.png"
WIN_WIDTH = 640
WIN_HEIGHT = 360

Puis un fichier de configuration conf.lua :

require('const')

function love.conf(t)
    t.window.title = TITLE -- Change le titre de la fenêtre
    t.window.icon = PATH_ICON -- Change l'icone de la fenêtre
    t.window.width = WIN_WIDTH -- Change la largeur de la fenêtre
    t.window.height = WIN_HEIGHT -- Change la hauteur de la fenêtre
    t.console = false
end

Enfin, on intègre tout ça dans la boucle de LÖVE à l'aide des méthodes load, update et draw :

require('utils')
require('landscape')
require('player')
require('enemy')

local player
local enemy
local score

function reset()
    score = 0
    resetPlayer()
    resetEnemy()
end

function love.load()
    -- font
    font = love.graphics.newFont(18)
    love.graphics.setFont(font)
    -- game
    loadLandscape()
    player = loadPlayer()
    enemy = loadEnemy()
    crashSound = love.audio.newSource("sounds/151624__qubodup__clank-car-crash-collision.wav", "static")
    music = love.audio.newSource("sounds/514960__deleted-user-11009121__synthwave-loop-100bpm.mp3", "static")
    music:setLooping(true)
    music:play()
    music:setVolume(0.5)
    score = 0
end

function love.update(dt)
    updateLandscape(dt)
    if player.alive == true then
        updatePlayer(dt)
        updateEnemy(dt)
        if collideRect(player, enemy) then
            crashSound:play()
            player.alive = false
        end
        score = score + 20*dt
    end
end

function love.draw()
    setScale()
    drawLandscape()

    if player.alive == true then
        drawPlayer()
        drawEnemy()
        -- score
        love.graphics.print({{2/255,9/255,4/255,1}, 'score: '..math.floor(score)},8,8)
    else
        love.graphics.printf({{2/255,9/255,4/255,1}, 'Multipla Adventure'},0,WIN_HEIGHT/3,WIN_WIDTH,"center")
        love.graphics.printf({{2/255,9/255,4/255,1}, "Press space to play and jump "},0,WIN_HEIGHT/3+32,WIN_WIDTH,"center")
        if score ~= 0 then
            love.graphics.printf({{2/255,9/255,4/255,1}, "your score: ".. math.floor(score)},0,WIN_HEIGHT/3+64,WIN_WIDTH,"center")
        end
    end
end


function love.keyreleased(key)
    if player.alive == false then
        reset()
    end
    if key == "escape" then
        love.event.quit()
    end
end

function love.touchreleased( id, x, y, dx, dy, pressure )
    if player.alive == false then
        reset()
    end
end

Il ne reste plus qu'à exécuter LÖVE depuis le dossier du jeu pour voir le résultat :

love .

Happy coding !

Man vs. Wild: Angular

2020-05-21T00:00:00+02:00

Ah Angular... Sujet de débat éternel pour tous les trolls des technos front. Ce framework est soit détesté, soit adulé, mais on est rarement dans la nuance. Pour le coup je botte un peu en touche, car mes sentiments à l'égard d'Angular font office de montagnes russes. Et après m'être battu pendant 2 ans avec ce framework pour un projet pro, j'avais envie de te faire un petit retour des choses que j'aurai aimé savoir dès le début pour m'en sortir avec cette stack et ses concepts.

Editeur

De ce que j'ai pu tester, l'éditeur le plus simple à prendre en main pour Angular (et de loin) est VS Code. J'ai un peu testé Intellij, Atom et Vim, mais je suis très vite retourné sur VS Code.

Plugins

Au niveau des plugins, mes quelques indispensables sont:

Angular 8 Snippets: Snippets pour angular, material et ngrx.
Prettier: Formatage automatique du code.
Tsint: Linter typescript.
Bracket Pair Colorizer : Pour s'en sortir avec les parenthèses !

Rxjs

On attaque directement avec le plus important. Rxjs est une libraire de reactive programming permettant de travailler avec des flux de données asynchrones. Il faut savoir que Angular repose complètement sur cette librairie et qu'il est absolument vital de la maîtriser. Toute la technicité du code va en grande partie dépendre de Rxjs.

Opérateurs

Il faut absolument en maitriser les principaux opérateurs comme switchMap, combineLatest, filter, debounce et autres. Si ce n'est pas déjà fait, commence par aller sur learnrxjs.io et fait le tour des opérateurs, joue avec, essaye de les comprendre et de les garder en tête.

Marble tests

Il est possible de faire des tests unitaires plutôt poussés de tes flux avec des marble tests. La documentation officielle est pas trop mal faite, mais il faut savoir que c'est pas forcément évident à appréhender.

Pour info ca ressemble à ça:

import { TestScheduler } from 'rxjs/testing';

const testScheduler = new TestScheduler((actual, expected) => {
  // asserting the two objects are equal
  // e.g. using chai.
  expect(actual).deep.equal(expected);
});

// This test will actually run *synchronously*
it('generate the stream correctly', () => {
  testScheduler.run(helpers => {
    const { cold, expectObservable, expectSubscriptions } = helpers;
    const e1 =  cold('-a--b--c---|');
    const subs =     '^----------!';
    const expected = '-a-----c---|';

    expectObservable(e1.pipe(throttleTime(3, testScheduler))).toBe(expected);
    expectSubscriptions(e1.subscriptions).toBe(subs);
  });
});

Resolver avec du cache

En Angular, les resolvers sont des services qui permettent de récupérer des données d'une api avant d'afficher une page. Il est intéressant de savoir qu'il est possible de gérer facilement du cache avec l'opérateur shareReplay de rxjs de cette manière:

import { Injectable } from '@angular/core';
import { Resolve, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
import { Observable } from 'rxjs';
import { Country, NomenclatureService } from 'ins-common-lib';
import { shareReplay } from 'rxjs/operators';

@Injectable({
    providedIn: 'root'
})
export class PaysResolver implements Resolve<Country[]> {
    private pays$: Observable<Country[]>;

    constructor(private service: NomenclatureService) {}

    resolve(_route: ActivatedRouteSnapshot, _state: RouterStateSnapshot): Observable<Country[]> {
        if (!this.pays$) {
            this.pays$ = this.service.listCountries().pipe(shareReplay(1, 3600000));
        }
        return this.pays$;
    }
}

Ici, le resolver récupère la première requête et la met en cache pendant 1h. Pratique pour éviter de faire des appels systématiques à l'api !

Store

L'utilisation d'un store type Redux pour Angular est très intéressant pour les gros projets. Ça permet de débugger plus facilement l'application et ça facilite l'intéraction entre plusieurs pages en partageant des données. Le store le plus utilisé par la communauté est Ngrx, donc je t'invite à partir sur celui-là si tu n'a pas de préférences particulières. Potasse un peu la doc officielle pour en comprendre le fonctionnement. Après rxjs, c'est la deuxième librairie qu'il est vital de maîtriser.

Debug

L'outil de debug indispensable est le Redux Devtools. Ça va te permettre de visualiser ton store en direct et de lancer des actions manuellement.

Facade

Plutôt que de manipuler directement le store dans les composants, je te conseille d'utiliser un service Angular qui va s'en charger. Dans ce service, tu vas y mettre tes appels aux sélecteurs, l'éxecution de tes actions et autres. C'est une manière d'utiliser le design pattern façade. Tu peux jeter un oeil à cet article où c'est bien expliqué. Concrètement ta façade va ressembler à ça :

@Injectable()
export class CarsFacade {
  loaded$ = this.store.select(carsQuery.getIsLoaded);
  allCars$ = this.store.select(carsQuery.getAllCars);
  selectedCar$ = this.store.select(carsQuery.getSelectedCar);

  constructor(private store: Store<CarsState>) {}

  loadAllCars() {
    this.store.dispatch(new LoadCar());
  }

  selectCar(carId: string) {
    this.store.dispatch(new SelectCar(carId));
  }
}

Et c'est donc ce service que tu vas injecter dans tes composants plutôt que le store directement ! Ça permet de garder des composants plus lisibles, et d'isoler la partie store. Si un jour tu migres de technos de store, il te suffira de modifier les façades.

Formulaires

Il est possible de gérer nos formulaires Angular directement dans le store ngrx. C'est vraiment très pratique si tu dois faire une application avec beaucoup de formulaires complexes. Ça facilite grandement le debug des formulaires et on a une manière propre de les créer. Cette librairie s'appelle ngrx-forms et est vraiment au top !

Error thrown

J'en ai fait des cauchemars de celle-là ! Si tu fais des tests unitaires pour ton application Angular, tu risques de la rencontrer souvent. Elle peut survenir aléatoirement et c'est dur à débugguer, une horreur. Mais en gros, après m'être arraché les cheveux, si tu rencontre un Error thrown à l'exécution de tes tests unitaires, c'est qu'il te manque dans 99% des cas l'importation et l'initialisation de données de ton store quelque part dans un des tests.

UI

Niveau UI, tu peux partir sur la librairie de composants Angular Material. Elle a l'avantage d'être open source et d'être officiellement supportée par Angular.

Material

Quand tu as des doutes sur l'utilisation de tes composants material, n'hésite pas à te référer à la documentation officielle de google sur material, c'est une mine d'or.

Theme

Il est possible de faire ton propre theme. Et de la même manière, tu peux également themer tes propres composants customisés.

Angular

Allez on y est presque, place aux tips sur les mécaniques internes de Angular.

i18n

Avec le module i18n de Angular, il est possible d'internationaliser les templates. Oui... mais il faut savoir qu'il ne permet pas d'internationaliser les chaines de caractères en dehors des templates ! C'est une demande qui est ouverte depuis 4 ans et qui n'a toujours pas été résolue. Donc il faut soit prendre son mal en patience, soit utiliser une librairie externe pour l'internationalisation, ou alors gérer ça dans le code à la main.

Franchement, en comparaison d'autres frameworks, l'internationalisation dans Angular n'est vraiment pas terrible. Et en plus il faut se taper des fichiers xml ...

Schematics

Les schematics sont les templates utilisés par angular cli pour générer les composants, les modules et autres. C'est pratique à utiliser, par contre c'est une horreur à écrire. Franchement, ne perds pas de temps à en créer, car ça ne te servira pas à grand chose au final.

Lazy loading

Pour gagner en performance, il faut savoir qu'il est possible de découper son application en plusieurs sous-modules lazy loadés. Ça permet à l'application de répondre rapidement lorsque l'on va sur la page d'accueil, et de charger les modules nécessaires que lorsqu'ils sont vraiment demandés par l'utilisateur. Il suffit de déclarer nos modules de cette manière dans le fichier de routing :

const routes: Routes = [
  {
    path: 'items',
    loadChildren: () => import('./items/items.module').then(m => m.ItemsModule)
  }
];

Guards vs Resolvers

La différence entre les deux concepts n'est pas toujours bien comprise, donc on va juste faire un petit point ici:

Les Guards sont utilisés pour autoriser ou non l'utilisateur à accéder à une page. On va y faire des contrôles sur l'authentification et sur les autorisations.
Les Resolvers sont utilisés pour récupérer des données d'une api nécessaire au bon fonctionnement d'un page, comme des nomenclatures ou autres.

Evite donc d'utiliser les guards pour récupérer des données qui n'ont rien à voir avec les autorisations !

Detection des changements

Si tu rencontre des soucis au niveau de la detection des changements, verifie que tu n'as pas une stratégie particulière type ChangeDetectionStrategy.OnPush sur ton composant. Cette stratégie permet d'avoir de meilleurs performances mais risque de ne pas détecter les changements sur les variables en dehors des inputs. Donc pour des petits composants qui fonctionnent uniquement à base de input/output c'est parfait, mais pour le reste il faut se méfier.

Librairies et workspaces

Il y a quelques temps encore, il fallait installer et gérer ng-packagr à la main pour créer des libraires. Aujourd'hui, c'est directement disponible via angular cli. Voici les commandes pour créer, tester, builder et publier une librairie :

ng new my-workspace --create-application=false
cd my-workspace
ng generate library my-lib
ng build my-lib
ng test my-lib
ng lint my-lib
ng build my-lib --prod
cd dist/my-lib
npm publish

Il est également possible de créer un workspace qui va contenir plusieurs applications et librairies pour un même projet.

ng new my-workspace --createApplication="false"
cd my-workspace
ng generate library my-first-lib
ng generate library my-second-lib
ng generate application my-first-app
ng generate application my-second-app

C'est pratique dans le cas où tu aurais plusieurs applications qui partagent des librairies communes. Par exemple, on pourrait imaginer une application pour les clients et une pour l'administration du site avec des modèles métier en commun dans une librarie partagée.

Mot de la fin

Et voilà, on a plus ou moins fait le tour de quelques tips que j'aurai bien aimé savoir en début de projet pour gagner du temps. Si un de ces points a pu t'aider, n'hésite pas à en faire part dans les commentaires. Bon courage !

Les killer features d'Elixir

2018-08-03T00:00:00+02:00

Ça fait un petit moment que j'ai dans l'idée de bosser un langage fonctionnel, histoire d'améliorer mes compétences de dev en m'entrainant à réfléchir autrement. Haskell m'attirait beaucoup, car il semblait représenter la perfection du paradigme fonctionnel. Mais bon, il faut vraiment prendre le temps de s'y investir, et il n'est pas simple de l'utiliser rapidement pour nos petits use-cases quotidiens.

Quand aux langages de type Lisp, c'est intéressant et rigolo mais utiliser des milliers de parenthèses partout, très peu pour moi (ok je sais, c'est cliché mais c'est comme ça).

C'est alors que plusieurs langages dits modernes fîrent leur apparition, comme Go, Rust, Elixir et Crystal. Et j'ai dans mon entourage des devs qui ont fait le cheminement suivant :

Python -> Go -> Elixir

Après avoir entendu beaucoup de bien d'Elixir, j'ai décidé de m'y mettre et je ne suis pour l'instant pas déçu !

Du coup, j'avais envie de te montrer les quelques killer features d'Elixir pour un dev qui vient principalement du monde Python à la base.

Pour la petite histoire, c'est un langage inventé par un ancien dev de Ruby on Rails, donc on a droit une syntaxe toute mimi. Et ça tourne sur la VM Erlang, qui est réputée comme étant très performante en programmation concurrente.

Compréhension

Alléluia, on a les listes et dictionnaires compréhensions. Comme tout pythoneux qui se respecte, ça fait plaisir de voir ça ici !

En Python, on écrirait par exemple une petite liste compréhension de cette manière :

>>> myList = [x * x for x in [1, 2, 3, 4] if x > 2]
>>> myList
[9, 16]

En Elixir, ça donne ça :

iex> myList = for x <- 1..4, x > 2, do: x * x
[9, 16]

Et pour faire un dictionnaire compréhension à partir d'une liste, en Python on ferait ça :

>>> myDict = {x: x**2 for x in [1, 2, 3, 4] if x % 2 == 0}
>>> myDict
{2: 4, 4: 16}

En Elixir, ça donne ça :

iex> myDict = for x <- 1..4, rem(x, 2) == 0, into: %{}, do: {x, x * x}
%{2 => 4, 4 => 16}

Tu remarqueras qu'Elixir utilise le typage dynamique comme en Python, du coup on peut avoir un syntaxe assez concise.

Fonction anonyme

Dans Elixir, on a droit aux fonctions anonymes, qui sont beaucoup plus poussées que les lambdas de Python.

En Python:

>>> add = lambda a, b: a + b
>>> add(3, 4)
7

En Elixir :

iex> add = fn a, b -> a + b end
iex> add.(3, 4)
7

Ici on a un exemple relativement simple, mais sache que tu n'as pas de limitation de syntaxe dans les fonctions anonymes d'Elixir.

Il s'agit également de closures, donc elles ont accès aux variables du scope. Tu remarqueras la syntaxe .( pour l'appel de la fonction. C'est une volonté d'Elixir de différencier les appels des fonctions anonymes par rapport au appels des fonctions normales.

Pattern matching

Sûrement le plus gros point fort de ce langage, ce qui le rend unique. Le symbole = ne sert non pas à assigner une variable, mais à faire du pattern matching.

En effet, pour faire simple, en Elixir lorsque tu fais x = 1, le langage essaye de matcher l'expression de droite avec celle de gauche. On pourra voir l'assignation de la variable x comme une conséquence de ce pattern matching.

Ça permet de faire tout un tas de choses, par exemple :

iex> {a, b, c} = {:hello, "world", 42}
{:hello, "world", 42}
iex> a
:hello
iex> b
"world"

Tu remarqueras le :hello, qui est en réalité un atom. C'est en gros une constante qui porte comme nom de variable sa valeur. les true et false du langage sont des atoms par exemple.

Pour récupérer le head et le tail d'une liste via le pattern matching :

iex> [head | tail] = [1, 2, 3]
[1, 2, 3]
iex> head
1
iex> tail
[2, 3]

Mais là où c'est vraiment fort, c'est que ce pattern matching fonctionne également pour les arguments des fonctions. Et on va alors pouvoir écrire une fonction qui va se comporter différemment en fonction des arguments d'entrée. Ça peut faire penser à Java, mais via le pattern matching, c'est vraiment plus puissant.

On imagine ici une fonction que se comporterait différemment en fonction du JSON qu'elle a reçu par exemple. Ici, on effectue des répartions différentes selon le véhicule passé en entrée.

iex> defmodule Garage do
         def repair(%{"voitures" => %{ "marque" => "peugeot"}}) do
             IO.puts("on traite les voitures peugeots")
         end
         def repair(%{"motos" => %{ "couleur" => "rouge"}}) do
             IO.puts("on traite les motos rouges")
         end
         def repair(_) do
             IO.puts("on traite le reste")
         end
     end

iex> Garage.repair(%{
         "voitures" => %{
            "marque" => "peugeot",
            "roues" => 4,
            "couleur" => "rouge"
         }
     })
on traite les voitures peugeots

iex> Garage.repair(%{
         "motos" => %{
             "marque" => "ducati",
             "roues" => 2,
             "couleur" => "rouge"
         }
     })
on traite les motos rouges

iex> Garage.repair(%{
         "motos" => %{
             "marque" => "derbi",
             "roues" => 2,
             "couleur" => "noir"
         }
     })
on traite le reste

Plutôt sympa nan ? Ça peut nous éviter pas mal de bloc type if ... else ce genre de syntaxe !

Pipe

L'opérateur unix ultime, qui manque cruellement à Python, est bien présent dans Elixir !

Tu peux du coup faire ce genre de truc :

iex> "i love elixir" |> String.split |> Enum.take(-1) |> Enum.join(" ") |> String.capitalize
"Elixir"

Processus

On en vient à ce qui permet à Elixir d'avoir des performances de malade. Elixir gère la concurrence à travers des processus internes. Alors attention, ça n'a rien à voir avec les processus systèmes. C'est un fonctionnement interne à la VM Erlang, on peut donc en avoir des millions sans que ça pose problème au niveau de la machine.

Pour ce faire, on a juste 3 mots clés à retenir : spawn, send et receive.

Avec spawn, on lance un nouveau processus, tandis que send et receive vont servir à envoyer et reçevoir des messages à travers les processus.

Ça ressemble un peu au système de goroutines de Go. On pourrait voir le mot clé spawn équivalent au mot clé go de Go, et le système send/receive comme le système de channel de Go.

iex> parent = self()
#PID<0.41.0>
iex> spawn fn -> send(parent, {:hello, self()}) end
#PID<0.48.0>
iex> receive do
...>   {:hello, pid} -> "Got hello from #{inspect pid}"
...> end
"Got hello from #PID<0.48.0>"

Dans cet exemple, on a notre processus parent qui reçoit un message du processus 48 qui a été spawné.

Bonus

En bonus, on a également droit à tout ce qui vient du monde des langages fonctionnels, à savoir l'immutabilité, les closures, les fonctions d'ordre supérieur, la récursivité à la place des boucles for, les fonctions pures etc ...

Voilà, j'espère t'avoir donné envie de t'intéresser à cet excellent langage ! Et ce n'est qu'un bref aperçu de toutes ses possibilités !

Munch, un dictionnaire qui supporte les accesseurs

2017-11-09T00:00:00+01:00

Munch est une petite librairie bien pratique et bien pensé.

En gros, elle permet d'utiliser les accesseurs pour accéder aux éléments de tes dictionnaires, à la manière d'un objet python.

Ça peut être utile notamment dans les tests unitaires, si tu as besoin de mocker rapidement un objet par exemple.

Tu écris un dictionnaire qui correspond à ton objet, tu le munchify et hop !

Si dans une fonction que tu veux tester, tu as utilisé des accesseurs sur un objet, ton munch sera considéré comme l'objet en question.

C'est à priori un fork de Bunch, mais maintenu et qui fonctionne en python 3.

Tu l'installes avec pip :

pip install munch

Tu importes munchify et tu convertis ton dictionnaire en munch :

>>> from munch import munchify

>>> data = {
        "last_name": "Dupont",
        "first_name": "Jean",
        "age": 30,
        "activities": ["football", "ping-pong"],
        "job": {
            "name": "Developer",
            "enterprise": "Mozilla"
        }
    }

>>> mymunch = munchify(data)

>>> mymunch.last_name
'Dupont'
>>> mymunch.first_name = "Pierre"
>>> mymunch.first_name
'Pierre'
>>> mymunch.activities[0]
'football'
>>> mymunch.job.enterprise
'Mozilla'

Voilà c'est tout !

Tu as accès aux différentes méthodes des dictionnaires, comme keys() et update(), ainsi qu'à l'itération et à l'opérateur splat. Ça supporte également la sérialization en JSON et en YAML.

Thématique DevOps avec Ansible

2017-09-29T00:00:00+02:00

Ansible est un configuration management tool, c'est-à-dire que c'est un outil qui va te permettre d'administrer tes serveurs et d'y déployer automatiquement tes applications.

Et franchement, ça bute !

C'est très puissant tout en étant relativement simple à prendre en main, à l'inverse d'outils plus compliqués comme Chef ou Puppet par exemple.

En gros, ça va remplacer tes bons vieux scripts shell ou fabfile.

Installation

Vagrant

Pour tester Ansible, tu vas utiliser Virtualbox avec Vagrant pour te monter deux petites VMs Ubuntu Xenial.

Sous Ubuntu, tu peux installer tout ça via la commande suivante et redémarrer ta machine si besoin:

sudo apt-get install virtualbox virtualbox-dkms vagrant

Dans l'idéal, essaye d'avoir une version assez récente de Vagrant. Les fichiers de conf peuvent changer selon les versions.

Ensuite, tu te crées le fichier Vagrantfile suivant dans ~/tuto_ansible/vagrant/Vagrantfile par exemple:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure(2) do |config|

    config.vm.define "vm1" do | vm1 |
        vm1.vm.box = "ubuntu/xenial64"
        config.vm.network :forwarded_port, guest: 22, host: 2200, id: "ssh"
        config.vm.network :forwarded_port, guest: 80, host: 8010, id: "http"
    end

    config.vm.define "vm2" do | vm2 |
        vm2.vm.box = "ubuntu/xenial64"
        config.vm.network :forwarded_port, guest: 22, host: 2201, id: "ssh"
        config.vm.network :forwarded_port, guest: 80, host: 8011, id: "http"
    end

end

Et tu démarres tes deux VMs via:

cd ~/tuto_ansible/vagrant/
vagrant up

Ansible

Tu installes Ansible sous Ubuntu via :

sudo apt-get install software-properties-common
sudo apt-add-repository ppa:ansible/ansible
sudo apt-get update
sudo apt-get install ansible

Puis tu crées un fichier hosts à la racine du projet, dans ~/tuto_ansible/hosts:

[ubuntu]
vm1 ansible_host=127.0.0.1 ansible_port=2200 ansible_user=ubuntu ansible_become=yes env=test
vm2 ansible_host=127.0.0.1 ansible_port=2201 ansible_user=ubuntu ansible_become=yes env=prod

Et tu édites un fichier ansible.cfg qui va contenir ta configuration Ansible, dans ~/tuto_ansible/ansible.cfg:

[defaults]
inventory      = hosts

Tu as désormais indiqué à Ansible d'utiliser tes deux Vms précédemment créées.

Tout est prêt !

La commande ansible

Déjà, tu te places dans le répertoire ~/tuto_ansible pour pouvoir lancer les commandes:

cd ~/tuto_ansible

Ansible a besoin de python sur les machines clientes, donc si c'est pas installé par défaut:

ansible all -m raw -a "apt install -y python" --ask-sudo-pass

L'astuce ici c'est que l'option -m raw permet d'exécuter directement une commande ssh sans Ansible.

Et tu essayes maintenant de contacter tes deux VMs via:

ansible all -m ping

Si tout est ok à ce niveau-là, tu peux passer à la suite. Sinon c'est qu'il y a un souci quelque-part.

Tu vas maintenant pouvoir utiliser la commande ansible pour faire des trucs sur les serveurs comme:

Exécuter une commande pour afficher la liste des utilisateurs de la première machine:

ansible vm1 -m shell -a "cat /etc/passwd"

S’assurer que openssl et bash sont à jour sur tous les serveurs ubuntu.

ansible ubuntu -m apt -a "name=openssl,bash state=latest"

Créer un utilisateur ansible avec un shell /bin/bash.

ansible ubuntu -m user -a "name=ansible shell=/bin/bash"

Installer la clef publique SSH de notre utilisateur sur l’utilisateur ansible.

ansible ubuntu -m authorized_key -a "user=ansible state=present key={{ lookup('file', '~/.ssh/id_rsa.pub') }}"

S’assurer des bons droits sur /etc/passwd (0644) et /etc/shadow (0400).

ansible ubuntu -m file -a "path=/etc/passwd mode=0664"
ansible ubuntu -m file -a "path=/etc/shadow mode=0400"

Playbooks

La commande ansible c'est bien mais ça va un moment. Ce que tu veux, c'est avoir une recette à exécuter qui s'occupe de mettre à jour ou non ce dont tu as besoin sur les machines distantes. Cette recette, ça s'appelle un playbook.

Tu vas donc écrire un playbook permettant de :

installer le paquet sudo.
créer un utilisateur ansible.
importer une clé SSH publique pour cet utilisateur.
configurer sudo pour cet utilisateur (sans mot de passe).
installer Apache avec le support de PHP activé pour les distributions Ubuntu.

Tu crées le fichier ~/tuto_ansible/myplaybook1.yml :

---

- hosts: ubuntu
  become: yes
  tasks:
  - name: "Installation de sudo sur {{ ansible_distribution }}"
    apt:
      name: sudo
      state: latest
    when: ansible_distribution == 'Ubuntu'
  - name: Ajout d'un user
    user:
      name: ansible
      shell: /bin/bash
  - name: Clé ssh
    authorized_key:
      user: ansible
      state: present
      key: "{{ lookup('file', '~/.ssh/id_rsa.pub') }}"
  - name: Ajout du user dans les sudoers
    lineinfile:
      dest: /etc/sudoers
      state: present
      line: 'ansible ALL=(ALL) NOPASSWD: ALL'
      validate: 'visudo -cf %s'
  - name: "Installation de apache sur {{ ansible_distribution }}"
    apt:
      name:
        - apache2
        - php
        - libapache2-mod-php
      state: latest
    when: ansible_distribution == 'Ubuntu'
    tags:
      - install_apache
  - name: Apache php
    apache2_module:
      name: php7.0
      state: present
    notify: Restart Apache
  handlers:
  - name: Restart Apache
    service:
      name: apache2
      state: restarted

Regarde bien en détail le playbook:

hosts précise sur quelles machines exécuter les tâches.
become indique qu'il faut être sudoer.
tasks contient les différentes tâches à lancer.
apt, user, authorized_key, lineinfile, apache2_module et service sont des modules.
when permet d'utiliser de la conditionnalité pour l'exécution des tâches.
name, state, key, shell, dest, line et autres sont les paramètres des modules. Pour voir la doc d'un module, tu peux utiliser la commande:

ansible-doc apache2_module

Tu exécutes ton playbook:

ansible-playbook myplaybook1.yml

Et si tu te rends sur http://127.0.0.1:8010/ et http://127.0.0.1:8011/, tu obtiens bien la page par défaut de Apache:

wget http://127.0.0.1:8010/
wget http://127.0.0.1:8011/

Tu peux relancer plusieurs fois de suite le playbook, Ansible ne fera rien de plus sur les serveurs car rien n'a changé.

Templates

Dans ton playbook, tu peux également utiliser des templates pour déployer des fichiers de configuration. Si tu as l'habitude de Django ou Flask, ça tombe bien car c'est Jinja qui est utilisé par Ansible !

Tu vas maintenant mettre en place un message du jour (motd) sur les serveurs à l'aide d'un template.

Tu crées le template motd suivant dans ~/tuto_ansible/motd:

IP = {{ ansible_default_ipv4.address }}
OS = {{ ansible_distribution }}
{% if env == 'prod' %}
ENV = Production
{% elif env == 'test' %}
ENV = Test
{% endif %}

Et le playbook associé dans ~/tuto_ansible/motd.yml:

- hosts: ubuntu
  become: true
  tasks:
  - template:
      src: motd
      dest: /etc/motd
      owner: ansible
      group: ansible
      mode: 0640
      backup: yes

Tu lances ton playbook et tu testes tout ça:

ansible-playbook motd.yml

Tu devrais voir:

ssh -p 2200 ubuntu@127.0.0.1
...
IP = 10.0.2.15
OS = Ubuntu
ENV = Test
Last login: Fri Sep 29 06:45:30 2017 from 10.0.2.2
ubuntu@ubuntu-xenial:~$

Et:

ssh -p 2201 ubuntu@127.0.0.1
...
IP = 10.0.2.15
OS = Ubuntu
ENV = Production
Last login: Fri Sep 29 06:45:30 2017 from 10.0.2.2
ubuntu@ubuntu-xenial:~$

Rôles

Ce qui serait bien, ça serait de pouvoir organiser un peu mieux tout ça pour que tes playbooks soient réutilisables. Tu vas pour ce faire créer un rôle apache qui va installer Apache et le configurer à l'aide d'un template.

C'est parti ! Tu crées un répertoire ~/tuto_ansible/roles qui contient l'arborescence suivante:

roles
└── apache
    ├── handlers
    │   └── main.yml
    ├── tasks
    │   └── main.yml
    └── templates
        └── mysite.j2

Ou alors tu peux utiliser la commande ansible-galaxy pour initialiser l'arborescence complète d'un rôle:

ansible-galaxy init --offline --init-path ~/tuto_ansible/roles apache

Le dossier handlers va te permettre d'y mettre des tâches qui vont être exécutées à chaque notification de changement. C'est utile pour redémarrer Apache dès que c'est nécessaire par exemple.

Dans ~/tuto_ansible/roles/apache/handlers/main.yml, tu mets:

---
- name: Restart Apache
  service:
    name: apache2
    state: restarted

Le dossiers tasks va tout simplement contenir tes tâches.

Dans ~/tuto_ansible/roles/apache/tasks/main.yml, tu mets:

---
- name: Install Apache
  apt:
    name: apache2
    state: present
- name: Check Apache
  service:
    name: apache2
    enabled: true
    state: started
- name: Installation d'un vhost
  template:
    src: mysite.j2
    dest: /etc/apache2/sites-available/mysite.conf
- name: a2ensite mysite
  command: a2ensite mysite
  notify:
  - Restart Apache

Ça installe et démarre Apache, et ça déploie et active un site qui va utiliser la configuration du template mysite.j2.

Pour finir, dans le dossier templates sous ~/tuto_ansible/roles/apache/templates/mysite.j2, tu vas mettre la configuration de ton Virtual Host Apache:

<VirtualHost *:{{ http_port }}>
    ServerAdmin webmaster@{{ domain }}
    ServerName {{ domain }}
    DocumentRoot /var/www/
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Les variables http_port et domain seront à définir dans ton playbook principal. Tu édites donc un fichier ~/tuto_ansible/playbook-apache.yml et tu y configures ton rôle apache:

---
# role apache

- hosts: ubuntu
  become: true
  vars:
    http_port: 80
    domain: localhost
  roles:
  - apache

Tu l'exécutes:

ansible-playbook playbook-apache.yml

Et voilà Apache est bien installé et configuré !

Pour aller un peu plus loin, tu peux jeter un oeil aux rôles disponibles sur Galaxy, tu y trouveras sûrement ton bonheur !

Découverte du gestionnaire de files de tâches Celery

2017-09-28T00:00:00+02:00

C'est quoi ? Ça se mange ?

Celery est un gestionnaire de tâches asynchrone. Il s'occupe de créer des files d'attentes pour les tâches, de les distribuer sur un ou des workers et d'en répartir la charge. Intégré dans une application web, il va permettre d'ordonner l'exécution de tâches en background.

Cet outil va t'être utile dans de nombreux cas d'usages. Personnellement, je l'utilise pour une application de streaming de vidéos et il me permet de lancer les jobs d'encodage des médias sur différents serveurs.

Mais tu vas pouvoir lui laisser le soin de zipper/dézipper de gros fichiers, générer de nombreux documents pdf, lancer le téléchargement de fichiers en masse ou encore lancer des calculs sur plusieurs machines.

Mais pourquoi utiliser Celery et pas un autre outil ?

Déjà, il est mature et très utilisé dans la communauté Python. Son côté asynchrone lui donne de bonnes performances. De plus, il en existe une intégration dans Django. Il y a des clients implémentés dans d'autres languages, comme php ou node. Grâce à lui, tu vas pouvoir automatiser tout un tas de trucs en répartissant les workers et les clients sur différentes machines.

Broker, quésaco ?

La première notion à connaître est le broker. Il s'agit tout simplement de la file d'attente. Tu vas pouvoir utiliser plusieurs technos pour gérer le broker, comme RabbitMq, Redis, Mongodb, Sqlalchemy, ou même l'orm de Django.

C'est le broker qui va permettre la communication entre le(s) workers(s) et le(s) client(s). La techno recommandée par Celery est RabbitMq, qui utilise le protocole AMQP. Je t'en ai déjà parlé précédemment.

Backend, quésaco ?

La seconde notion à connaître est le backend. Celui-ci est optionnel et permet de monitorer et de garder une trace des états des tâches. Les options de stockage sont quasi-similaires à celle du broker (RabbitMq, Redis, etc ...)

Mon application web qui génère des archives AVANT Celery

Prenons l'exemple d'une petite application web qui a pour objectif de générer un document au format pdf pour chaque usager présent dans une base de données, par année de naissance.

Étape 1 : choisir une année de naissance
Étape 2 : cliquer sur "Générer"
Étape 3 : regarder la roue qui tourne
Étape 4 : se faire un café
Étape 5 : contempler la roue qui tourne
Étape 6 : se faire un autre café
Étape 7 : 504 Gateway Timeout

Mon application web qui génère des archives AVEC Celery

Étape 1 : choisir une année de naissance
Étape 2 : cliquer sur "Générer"
Étape 3 : choisir une autre année
Étape 4 : cliquer sur "Générer"
Étape 5 : choisir une autre année
Étape 6 : cliquer sur "Générer"
Étape 7: Mince, il est où mon café ?

Objectif

Pour se faire, l'objectif est d'arriver à une architecture de ce type:

Installation

Tu commences par installer RabbitMq:

Soit sous Ubuntu (tu prends la dernière version ici):

echo 'deb http://www.rabbitmq.com/debian/ testing main' | sudo tee /etc/apt/sources.list.d/rabbitmq.list
wget -O- https://www.rabbitmq.com/rabbitmq-release-signing-key.asc | sudo apt-key add -
sudo apt-get update && apt-get install rabbitmq-server

Soit via Docker:

docker run -d --hostname myrabbitmq --name myrabbitmq -p 5672:5672 rabbitmq:3

Puis tu installes Celery avec pip:

pip install celery==3.1.25

Oui je sais, il y a la version 4.1 de Celery qui est sortie cet été. Mais je n'ai pas encore eu le temps de me pencher dessus, donc il faudra sûrement mettre à jour ce tuto à l'avenir ! Désolé mon vieux !

Django - Configuration

Dans ton fichier de settings de django, par exemple myproject/settings.py, tu ajoutes les paramètres suivants:

CELERY_NAME = "myproject"
CELERY_BACKEND = "amqp"
CELERY_BROKER = "amqp://guest@localhost//"

Django - Worker

Ensuite, tu crées ton worker myproject/celery.py:

import os
from celery import Celery

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")

from django.conf import settings

app = Celery(settings.CELERY_NAME, backend=settings.CELERY_BACKEND
    broker=settings.CELERY_BROKER)

app.config_from_object('django.conf:settings')
app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)

@app.task(bind=True)
def debug_task(self):
    print('Request: {0!r}'.format(self.request))

Django - Création des tâches

Puis, tu crées les tâches qui vont te permettre de générer les documents pdf dans myproject/apps/myapp/tasks.py:

from celery import shared_task
from celery.signals import task_prerun, task_success, task_failure
from .utils import get_persons_and_generate_pdfs

@shared_task(bind=True) # utile pour les "reusable apps"
def task_generate_archive_files(self, date):
    """ generate pdf files """
    get_persons_and_generate_pdfs(date)

@task_prerun.connect(sender=task_generate_archive_files)
def start_generate_archive_files(sender=None, *args, **kwargs):
    print("Initialisation du statut du lot en base")

@task_success.connect(sender=task_generate_archive_files)
def success_generate_archive_files(sender=None, *args, **kwargs):
    print("Modification du statut du lot en réussi")

@task_failure.connect(sender=task_generate_archive_files)
def failure_generate_archive_files(sender=None, *args, **kwargs):
    print("Modification du statut du lot en échec")

Django - Appel des tâches

Enfin, tu gères l'appelles des tâches dans myproject/apps/myapp/views.py, par exemple:

from .tasks import task_generate_archive_files

@login_required()
def generate_archive_files(request, *args, **kwargs):
    if request.method == "POST":
        date = request.POST.get('birth_date')
        try:
            my_task = task_generate_archive_files.delay(date)
        except IntegrityError:
            messages.add_message(
                request, messages.ERROR, _("A file for one of those persons already exists"))
        else:
            messages.add_message(
                request, messages.INFO, _("A file creation task is scheduled"))
        return redirect(reverse("myproject-database:database", "?birth_date={}".format(date)))
    else:
        return HttpResponseForbidden()

À toi d'adapter le code pour que ça colle avec ton projet, tes urls, et autres. C'est qu'un exemple d'utilisation.

Django - Exécution

Pour exécuter celery, tu peux alors lancer la commande suivante:

celery -A myproject worker -l info

Tu peux même te faire un petit Makefile dans ce genre:

RABBITMQ := rabbitmq-myproject
CELERY := myproject

run-rabbitmq:
    docker ps -aq --filter name=$(RABBITMQ) | xargs -r docker rm -f -v && \
    docker run -d --hostname $(RABBITMQ) --name $(RABBITMQ) -p 5672:5672 rabbitmq:3

run-celery: run-rabbitmq
    celery -A $(CELERY) worker -l info

.PHONY: un-rabbitmq run-celery

Debug

Tu vas alors avoir un écran de debug qui ressemble à ça:

[2016-10-21 16:47:18,568: INFO/MainProcess] Connected to amqp://guest:**@127.0.0.1:5672//
[2016-10-21 16:47:18,615: INFO/MainProcess] mingle: searching for neighbors
[2016-10-21 16:47:19,628: INFO/MainProcess] mingle: all alone
[2016-10-21 16:50:23,354: INFO/MainProcess] Received task: myproject.apps.file.
tasks.task_generate_archive_files[1755cd30-03f5-4d8a-8d92-fa5b1853a209]
...
...
...
[2016-10-21 16:50:26,944: INFO/MainProcess] Task myproject.apps.file.
tasks.task_generate_archive_files[1755cd30-03f5-4d8a-8d92-fa5b1853a209]
succeeded in 3.588768539018929s: '1755cd30-03f5-4d8a-8d92-fa5b1853a209'

Tests unitaires

Pour lancer des tests unitaires sur tes tâches dans ton projet Django, tu peux utiliser le paramètre suivant dans tes settings:

CELERY_ALWAYS_EAGER = True

Ça permet de tester les tâches Celery de manière synchrone et sans broker (il utilise un genre de broker en mémoire).

Déploiement avec init.d

Il existe un dépôt d'helpers pour déployer avec init.d ou systemd. Par exemple pour init.d :

Mettre le fichier celeryd du dépôt d'helpers dans /etc/init.d.
Mettre la configuration suivante dans /etc/default/celeryd:

export DJANGO_SETTINGS_MODULE="myproject.settings"

CELERYD_NODES="worker1"
CELERY_BIN="/home/myuser/.virtualenvs/myproject/bin/celery"
CELERY_APP="myproject"
CELERYD_CHDIR="/home/myuser/myproject"
CELERYD_OPTS="--time-limit=300 --concurrency=8"
CELERYD_LOG_FILE="/var/log/celery/%N.log"
CELERYD_PID_FILE="/var/run/celery/%N.pid"
CELERYD_USER="myuser"
CELERYD_GROUP="mygroup"
CELERY_CREATE_DIRS=1

Monitoring - Exemples

Voir le résultat d'une tâche :

celery -A myproject result -t tasks.add 4e196aa4-0141-4601-8138-7aa33db0f577

Voir liste des workers actifs :

celery -A myproject status

Voir les tâches actives :

celery -A myproject inspect active

Voir les statistiques des workers :

celery -A myproject inspect stats

Sinon, il existe le projet flower pour monitorer et administrer les workers et les tâches via une appli web.

En vrac

Quelques tips en vrac:

Cron-like :

@periodic_task(run_every=crontab(hour='5,13,23', minute=30, day_of_week='monday'))
def mytask():
...

Sqlite n'aime pas les accès concurrents
Purger les tâches en attentes :

celery -A proj purge

Récupérer le statut d'une tâche :

result = my_task.AsyncResult(task_id)
result.state

Attendre le résultat d'une tâche :

result = my_task.AsyncResult(task_id)
result.get()

Appeler une tâche par son nom depuis une autre machine :

from celery import Celery
celery = Celery()
celery.config_from_object('celeryconfig')
celery.send_task('tasks.add', (2,2))

Appeler une tâches via HTTP :

from celery.task.http import URL
res = URL('http://example.com/multiply').get_async(x=10, y=10)

On peut appeler une tâche dans une tâche !
Pour l'optimisation, la sécurité, les extensions, la concurrence, voir la doc officielle.

Découverte du message broker RabbitMQ

2017-09-26T00:00:00+02:00

RabbitMQ est ce qu'on appelle un message broker.

Grosso-modo, ça sert à gérer des files de messages. Il permet ainsi de reçevoir et de transmettre des messages de différentes manières.

Je te le recommande fortement car c'est un outil léger, très robuste, performant et simple d'utilisation.

Il existe depuis plus de 10 ans maintenant et est utilisé dans de grosses entreprises comme Ford, Instagram ou le New York Times.

S'il fallait schématiser ce que représenterait Rabbitmq dans l'IRL, ça serait le bureau de poste, la boite aux lettres ainsi que le facteur !

Communication

Il utilise un protocole de communication appelé AMQP (Advanced Message Queuing Protocol), qui permet de standardiser les échanges. Ce protocole provient d'un consortium entre différentes entreprises tel que JPMorgan, Microsoft, Red Hat et Cisco.

Il en existe de nombreuses implémentations dans plein de langages, comme en Python avec Pika, en Java, en Php, en Javascript, en Ruby, etc...

Vocabulaire

Si tu fouilles un peu dans le doc officielle, tu remarqueras l'utilisation de certains vocabulaires.

Histoire de ne pas être complètement perdu, voici les plus importants :

Producer: celui qui envoie des messages
Queue: file qui stocke les messages
Consumer: celui qui reçoit les messages
Exchange: là où on peut déposer les messages

Installation

Sur Ubuntu, Rabbitmq est présent dans les dépôts officiels, donc rien de plus simple à installer:

# Install the package
apt-get install -y rabbitmq-server

À l'aide de rabbitmqctl, tu vas pouvoir ajouter des utilisateurs, gérer les permissions, créer des Virtual Hosts (oui, c'est bien le même concept que pour Apache), effacer des utilisateurs, etc...

# Add rabbitmq user
rabbitmqctl add_user myuser mypassword
# Add rabbitmq vhost
rabbitmqctl add_vhost myproject
# Add a tag to the user
rabbitmqctl set_user_tags myuser management
# Add vhost all permissions (conf, read, write) to the user
rabbitmqctl set_permissions -p myproject myuser ".*" ".*" ".*"
# Delete the guest user
rabbitmqctl delete_user guest
# Check user authentication
rabbitmqctl authenticate_user myuser mypassword

Ici, j'ai volontairement effacé l'utilisateur guest qui est activé par défaut.

Administration

Tu peux administrer Rabbitmq de deux manières:

Via une interface web disponible sur http://server-name:15672/ en activant le plugin management:

rabbitmq-plugins enable rabbitmq_management

ou en ligne de commande via rabbitmqctl:

# users
rabbitmqctl list_users
rabbitmqctl delete_user <username>
rabbitmqctl change_password <username> <newpassword>
# queue
rabbitmqctl list_queues -p myproject
rabbitmqctl purge_queue queue
rabbitmqctl list_connections
rabbitmqctl list_channels
rabbitmqctl list_consumers
rabbitmqctl list_exchanges
# vhost
rabbitmqctl list_vhosts
rabbitmqctl list_permissions -p myproject

Installation du client Python

Pour installer le client Python Pika, tu utilises pip comme d'hab':

pip install pika

Scénarios

Voyons maintenant les différents types de scénarios possibles pour son usage.

Hello World

Le producer envoie des messages dans la queue hello.
Le consumer reçoit les messages de cette queue.

Le code du producer send.py:

#!/usr/bin/env python
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

channel.basic_publish(exchange='',
                    routing_key='hello',
                    body='Hello World!')
print(" [x] Sent 'Hello World!'")
connection.close()

Le code du consumer receive.py:

#!/usr/bin/env python
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

channel.basic_consume(callback,
                    queue='hello',
                    no_ack=True)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

Et au final, tu as comme résultat:

python receive.py
# => [*] Waiting for messages. To exit press CTRL+C
# => [x] Received 'Hello World!'

python send.py
# => [x] Sent 'Hello World!'

Work queues

Le producer envoie des jobs à effectuer dans une queue.
Plusieurs consumers se répartissent les tâches.
C'est utile pour des tâches longues (encodage, importation, copies).

Le code du producer new_task.py:

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.queue_declare(queue='task_queue', durable=True)

message = ' '.join(sys.argv[1:]) or "Hello World!"
channel.basic_publish(exchange='',
                    routing_key='task_queue',
                    body=message,
                    properties=pika.BasicProperties(
                        delivery_mode = 2, # make message persistent
                    ))
print(" [x] Sent %r" % message)
connection.close()

Le code du consumer worker.py:

#!/usr/bin/env python
import pika
import time

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.queue_declare(queue='task_queue', durable=True)
print(' [*] Waiting for messages. To exit press CTRL+C')

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    time.sleep(body.count(b'.'))
    print(" [x] Done")
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_qos(prefetch_count=1)
channel.basic_consume(callback,
                    queue='task_queue')

channel.start_consuming()

Il suffit alors d'exécuter les fichiers pour simuler le fonctionnement de la file de jobs.

Routing

L'exchange de type direct redirige automatiquement dans la bonne file en fonction d'une clé.
C'est utile pour gérer des logs par exemple.

Le code du producer emit_log_direct.py:

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_logs',
                        exchange_type='direct')

severity = sys.argv[1] if len(sys.argv) > 2 else 'info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'
channel.basic_publish(exchange='direct_logs',
                    routing_key=severity,
                    body=message)
print(" [x] Sent %r:%r" % (severity, message))
connection.close()

Le code du consumer receive_logs_direct.py:

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='direct_logs',
                        exchange_type='direct')

result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

severities = sys.argv[1:]
if not severities:
    sys.stderr.write("Usage: %s [info] [warning] [error]\n" % sys.argv[0])
    sys.exit(1)

for severity in severities:
    channel.queue_bind(exchange='direct_logs',
                    queue=queue_name,
                    routing_key=severity)

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):
    print(" [x] %r:%r" % (method.routing_key, body))

channel.basic_consume(callback,
                    queue=queue_name,
                    no_ack=True)

channel.start_consuming()

Tu t'attends alors à reçevoir des messages de type info, warning et error:

python receive_logs_direct.py info warning error
# => [*] Waiting for logs. To exit press CTRL+C

Par exemple, pour émettre un message de type error:

python emit_log_direct.py error "Run. Run. Or it will explode."
# => [x] Sent 'error':'Run. Run. Or it will explode.'

Topics

L'exchange de type topic permet de rediriger sur la bonne file en fonction de critères multiples.
Le message avec la clé de routage quick.orange.rabbit ira dans les 2 files.

Le code du producer emit_log_topic.py:

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='topic_logs',
                        exchange_type='topic')

routing_key = sys.argv[1] if len(sys.argv) > 2 else 'anonymous.info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'
channel.basic_publish(exchange='topic_logs',
                    routing_key=routing_key,
                    body=message)
print(" [x] Sent %r:%r" % (routing_key, message))
connection.close()

Le code du consumer receive_logs_topic.py:

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='topic_logs',
                        exchange_type='topic')

result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

binding_keys = sys.argv[1:]
if not binding_keys:
    sys.stderr.write("Usage: %s [binding_key]...\n" % sys.argv[0])
    sys.exit(1)

for binding_key in binding_keys:
    channel.queue_bind(exchange='topic_logs',
                    queue=queue_name,
                    routing_key=binding_key)

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):
    print(" [x] %r:%r" % (method.routing_key, body))

channel.basic_consume(callback,
                    queue=queue_name,
                    no_ack=True)

channel.start_consuming()

Tu peux maintenant utiliser les topics de différentes manières :

# To receive all the logs run:
python receive_logs_topic.py "#"

# To receive all logs from the facility "kern":
python receive_logs_topic.py "kern.*"

# Or if you want to hear only about "critical" logs:
python receive_logs_topic.py "*.critical"

# You can create multiple bindings:
python receive_logs_topic.py "kern.*" "*.critical"

# And to emit a log with a routing key "kern.critical" type:
python emit_log_topic.py "kern.critical" "A critical kernel error"

RPC

RPC permet d'exécuter une fonction distante en mode Request/Reply.
Le client envoie une request avec une clé unique et le nom de la file de retour.
Le serveur attend les requêtes, exécute la fonction et retourne la réponse.

Le code de la partie server rpc_server.py :

#!/usr/bin/env python
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))

channel = connection.channel()

channel.queue_declare(queue='rpc_queue')

def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)

def on_request(ch, method, props, body):
    n = int(body)

    print(" [.] fib(%s)" % n)
    response = fib(n)

    ch.basic_publish(exchange='',
                    routing_key=props.reply_to,
                    properties=pika.BasicProperties(correlation_id = \
                                                        props.correlation_id),
                    body=str(response))
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_qos(prefetch_count=1)
channel.basic_consume(on_request, queue='rpc_queue')

print(" [x] Awaiting RPC requests")
channel.start_consuming()

Le code de la partie cliente rpc_client.py :

#!/usr/bin/env python
import pika
import uuid

class FibonacciRpcClient(object):
    def __init__(self):
        self.connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))

        self.channel = self.connection.channel()

        result = self.channel.queue_declare(exclusive=True)
        self.callback_queue = result.method.queue

        self.channel.basic_consume(self.on_response, no_ack=True,
                                queue=self.callback_queue)

    def on_response(self, ch, method, props, body):
        if self.corr_id == props.correlation_id:
            self.response = body

    def call(self, n):
        self.response = None
        self.corr_id = str(uuid.uuid4())
        self.channel.basic_publish(exchange='',
                                routing_key='rpc_queue',
                                properties=pika.BasicProperties(
                                        reply_to = self.callback_queue,
                                        correlation_id = self.corr_id,
                                        ),
                                body=str(n))
        while self.response is None:
            self.connection.process_data_events()
        return int(self.response)

fibonacci_rpc = FibonacciRpcClient()

print(" [x] Requesting fib(30)")
response = fibonacci_rpc.call(30)
print(" [.] Got %r" % response)

Et pour tester ça :

python rpc_server.py
# => [x] Awaiting RPC requests

python rpc_client.py
# => [x] Requesting fib(30)

Conclusion

Cette introduction résume la doc officielle, mais n'hésite pas à te plonger dedans pour plus de détail si besoin.

Il est possible, par exemple, d'activer la persistance des données, d'authentifier les connections via un serveur LDAP et autres.

Dans une prochaine partie, nous verrons comment utiliser Celery avec Rabbitmq.

Mes librairies python indispensables

2016-07-11T00:00:00+02:00

Ça y est c'est les vacances ! À toi le soleil, les plages, les cocotiers et ... les librairies python bien sûr !

Du coup, j'en profite pour te un faire petit listing de mes librairies indispensables en python. On ne sait jamais, peut-être que tu y découvriras quelque-chose d'utile !

Framework web

django: framework le plus réputé, qui a l'avantage d'avoir une tonne de support et de documentation. Indispensable pour créer des applications web complexes.
bottle: framework ultra minimaliste, idéal pour les applications web de petite taille.
pelican: générateur de site statique utilisé par ce blog ! Tuto dispo ici.

Base de données

sqlalchemy: orm python le plus avancé, tout simplement.
peewee: orm léger et simple, parfait pour des besoins pas trop complexes.
psycopg2: driver postgresql
cx-oracle: driver oracle
tinydb: base de données ultra minimaliste. Tuto dispo ici.

Http

httpie: client http en ligne de commande. Tuto dispo ici.
requests: librairie http la plus simple et le plus efficace.
britney et britney-utils: client SPORE, qui est une spécification de description d'APIs REST.
suds-jurko: client SOAP léger et simple d'usage.

Templating

jinja2: moteur de template le plus réputé, utilisé par django.
mako: moteur de template ultra performant. Tuto dispo ici.
cookiecutter: moteur de template de projet utilisant jinja2. Tu peux jeter un oeil à l'article de Sam sur le sujet. Exemples d'utilisation: simple-python-drybones et bottle-drybones.

Machine learning

scikit-learn: projet de machine learning qui provient du Google Summer Of Code 2007. Google est en train d'en faire une série du tutos sur youtube vraiment intéressante.

Déploiement

fabric: outil qui permet déployer des applications via ssh.
fabtools: ensemble de fonctionnalités pour fabric.
pydiploy: projet qui utilise fabric et fabtools pour automatiser le déploiement d'applications. Pour les applications django par exemple, il permet de déployer et de configurer toute la stack python/virtualenv/circus/chaussette/nginx.

Django

django-extensions: extension des commandes de django.
django-static-precompiler: librairie qui permet d'automatiser la précompilation des fichiers CoffeeScript, Livescript, Sass, Less et autres.
django-crispy: outil formidable pour créer des formulaires compatibles bootstrap. Tuto dispo ici.
django-workflows et django-workflow-activity: outils pour créer des worflows états/transitions.
django-drybones: template de projet django.
django-autocomplete-light: module d'autocomplétion pour les champs des formulaires.
django-countries: gestion des pays dans django. Tuto dispo ici.
django-simple-captcha: utilisation de captchas. Tuto dispo ici.
django-rest-framework (drf): excellente librairie pour créer des APIs REST.
django-fine-permissions: gestion des permissions fines, par champs et par utilisateur, pour drf.
django-filter: gestion des filtres des querysets qui fonctionne très bien avec drf.
django-hypnos: outil qui permet de générer automatiquement une api rest avec drf, à partir d'une base de données sqlite/postgresql/mysql/oracle existante.
django-cas-sso: client pour l'authentification CAS, qui supporte le Single-Sign-Out.
django-ldapdb: backend pour manipuler les entrées des annuaires LDAP.
django-oauth-toolkit: ensemble d'outils pour oauth2.

Test

tox: outil qui permet d'exécuter les tests unitaires sous plusieurs virtualenvs avec des configurations différentes. Tuto dispo ici.
coverage: outil d'analyse de la couverture du code.
prospector: outil utilisé par landsacape.io qui utilise les meilleurs linters python pour vérifier la qualité du code.

Doc

sphinx: outil de génération de documentation à partir de fichiers reStructuredText.

Wamp

crossbar: router wamp le plus avancé pour python. Il y a de nombreux articles chez Sam.
autobahn: implémentation du protocle wamp qui fonctionne très bien avec crossbar.

Wsgi

circus + chaussette + waitress: stack wsgi complète. Tuto dispo ici.

Date

python-dateutil: extension au module datetime de python.
pytz: gestion des timezones.

Script

docopt: librairie pour parser les arguments de script de manière élégante.
ipython: shell python le plus avancé.
apscheduler: planificateur de tâches à la manière des crons.

Crypto

pycrypto: outil de cryptographie, pour générer des hashs en sha256 par exemple.

Parsing

lxml: librairie pour lire/écrire du xml.
jsonschema: implémentation de JSON Schema.
pyyaml: librairie pour lire/écrire du yaml.
reportlab: outil de production de pdf.

En vrac

six: librairie pour la compatibilité python 2/python 3.
pytoolz: extension d'itertools et functools. Tuto dispo ici.
unidecode: libairie très pratique permet de remplacer des caractères unicode en ascii.

Bonnes découvertes et bonnes vacances !

Créer un formulaire sous django avec django-crispy-forms

2016-05-04T00:00:00+02:00

Django-crispy-forms est une application django qui va te permettre de construire, customiser et réutiliser tes formulaires en utilisant ton framework CSS favori. Il permet d'éviter d'écrire une tonne de code dans les templates et applique la philosophie DRY.

Par défaut, il supporte les frameworks CSS bootstrap, foundation et uni-form.

On va voir comment tu peux créer un formulaire d'enregistrement compatible avec bootstrap en utilisant des onglets, un captcha, une liste de pays et un date picker.

Pour simplifier ce tuto, on ne va pas s'occuper de l'internationalisation. Mais rien ne t'empêches de la mettre en place de ton côté.

1) L'installation et la configuration

C'est parti ! On suppose que tu as déjà installé python 3.5 avec virtualenvwrapper. Tu crées donc ton environnement virtuel et tu installes les librairies requises:

mkvirtualenv -p /usr/bin/python3.5 demo-django-crispy-forms
pip install Django==1.9.6 django-countries==3.4.1 django-crispy-forms==1.6.0 \
django-simple-captcha==0.5.1

La version compatible de django-bootstrap3-datetimepicker avec django 1.9 n'est pas encore disponible sur pypi. Du coup, tu l'installes directement depuis github:

pip install git+https://github.com/nkunihiko/django-bootstrap3-datetimepicker.git@2fa9ea5

Tu crées un projet django appelé demo-django-crispy-forms, qui contient une application core:

django-admin startproject demo_django_crispy_forms
cd demo_django_crispy_forms/demo_django_crispy_forms
mkdir apps && cd apps
django-admin startapp core

Dans le fichier settings.py de ton projet, tu modifies/ajoutes les lignes suivantes:

LANGUAGE_CODE = 'fr'
TIME_ZONE = 'Europe/Paris'
INSTALLED_APPS = (
    ...
    'crispy_forms',
    'django_countries',
    'bootstrap3_datetime',
    'captcha',
    'demo_django_crispy_forms.apps.core'
)
CRISPY_TEMPLATE_PACK = 'bootstrap3'

Tu as ainsi défini la langue et le time zone, ajouté les applications installées précédemment et utilisé le template bootstrap3 pour crispy-forms.

Il te suffit de migrer la base de données et de vérifier que tout est bon pour l'instant. Depuis le répertoire racine du projet, tu fais:

./manage.py migrate && ./manage.py check

2) Le modèle

Maintenant que tu as fini l'installation et le paramétrage des différentes libraires, tu vas pouvoir créer le modèle de ton inscription.

Dans apps/core/models.py, tu définis le modèle Registration suivant :

from django.db import models
from django_countries.fields import CountryField


class Registration(models.Model):
    """
    Modèle de l'inscription
    """
    CIVILITY_CHOICES = (
        ('M.', 'M.'),
        ('MME', 'Mme')
    )
    STREET_TYPE_CHOICES = (
        ('Boulevard', 'Boulevard'),
        ('Avenue', 'Avenue'),
        ('Cours', 'Cours'),
        ('Place', 'Place'),
        ('Rue', 'Rue'),
        ('Route', 'Route'),
        ('Voie', 'Voie'),
        ('Chemin', 'Chemin'),
        ('Square', 'Square'),
        ('Impasse', 'Impasse'),
        ('Rond-point', 'Rond-point'),
        ('Quai', 'Quai')
    )

    civility = models.CharField(max_length=3, choices=CIVILITY_CHOICES,
                                default='M.', verbose_name="Civilité")
    birth_name = models.CharField(max_length=255, verbose_name="Nom de naissance")
    last_name = models.CharField(max_length=255, blank=True, null=True,
                                 verbose_name="Nom d'usage ou marital")
    first_name = models.CharField(max_length=255, verbose_name="Prénom")
    birth_date = models.DateField(verbose_name="Date de naissance ")
    birth_place = models.CharField(max_length=255, verbose_name="Ville de naissance")
    birth_country = CountryField(max_length=255, verbose_name="Pays de naissance")
    mail = models.EmailField(max_length=255, verbose_name="Mail")
    street_type = models.CharField(max_length=30, verbose_name="Type de rue",
                                   choices=STREET_TYPE_CHOICES, default='Rue')
    street_number = models.CharField(max_length=30, verbose_name="Numéro de rue")
    street = models.CharField(max_length=30, verbose_name="Rue")
    comp_1 = models.CharField(max_length=255, verbose_name="Complément 1",
                              blank=True, null=True)
    comp_2 = models.CharField(max_length=255, verbose_name="Complément 2",
                              blank=True, null=True)
    city = models.CharField(max_length=255, verbose_name="Ville")
    zip_code = models.CharField(max_length=255, verbose_name="Code postal")
    country = CountryField(max_length=255, verbose_name="Pays")
    phone = models.CharField(max_length=255, blank=True, null=True,
                             verbose_name="Téléphone")
    comments = models.TextField(blank=True, null=True, verbose_name="Commentaires")

Pour chaque champ, crispy-forms va :

utiliser le verbose_name comme label.
vérifier les paramètres blank et null pour savoir si le champ est obligatoire.
utiliser le type de champ pour définir le type de la balise <input>.
récupérer les valeurs du paramètre choices (si présent) pour la balise <select>.

Enfin, tu mets à jour la base de données:

./manage.py makemigrations
./manage.py migrate

3) Le formulaire

Place au formulaire. J'ai rajouté des commentaires directement dans le code ci-dessous pour expliquer les différentes étapes.

Dans apps/core/forms.py, tu mets:

from django import forms
from .models import Registration
from crispy_forms.helper import FormHelper
from crispy_forms.bootstrap import StrictButton
from bootstrap3_datetime.widgets import DateTimePicker
from crispy_forms.layout import Layout
from crispy_forms.bootstrap import TabHolder, Tab
from captcha.fields import CaptchaField


class RegistrationForm(forms.ModelForm):
    """
    Formulaire d'inscription
    """

    # Ici, tu vas rajouter les champs supplémentaires au modèle
    # Tu définis le captcha
    captcha = CaptchaField()
    # Tu ajoutes un mail de confirmation
    confirmation_mail = forms.EmailField(label="Mail de confirmation")

    def __init__(self, *args, **kwargs):
        """
        Surcharge de l'initialisation du formulaire
        """
        super().__init__(*args, **kwargs)
        # Tu modifies le label de la date de naissance pour rajouter le format
        self.fields['birth_date'].label = "%s (JJ/MM/AAAA)" % "Date de naissance"
        # Tu utilises FormHelper pour customiser ton formulaire
        self.helper = FormHelper()
        # Tu définis l'id et la classe bootstrap de ton formulaire
        self.helper.form_class = 'form-horizontal'
        self.helper.form_id = 'registration-form'
        # Tu définis la taille des labels et des champs sur la grille
        self.helper.label_class = 'col-md-2'
        self.helper.field_class = 'col-md-8'
        # Tu crées l'affichage de ton formulaire
        self.helper.layout = Layout(
            # Le formulaire va contenir 3 onglets
            TabHolder(
                # Premier onglet
                Tab(
                    # Label de l'onglet
                    'Étape 1 - Identité',
                    # Liste des champs du modèle à afficher dans l'onglet
                    'civility',
                    'birth_name',
                    'last_name',
                    'first_name',
                    'birth_date',
                    'birth_place',
                    'birth_country',
                    # Tu rajoutes un bouton "Suivant"
                    StrictButton(
                        '<span class="glyphicon glyphicon-arrow-right" \
                        aria-hidden="true"></span> %s' % "Suivant",
                        type='button',
                        css_class='btn-default col-md-offset-9 btnNext',
                    )

                ),
                # Deuxième onglet
                Tab(
                    # Label de l'onglet
                    'Étape 2 - Adresse',
                    # Liste des champs à afficher
                    'street_number',
                    'street_type',
                    'street',
                    'comp_1',
                    'comp_2',
                    'city',
                    'zip_code',
                    'country',
                    'phone',
                    # Tu rajoutes des boutons "Précédent" et "Suivant"
                    StrictButton(
                        '<span class="glyphicon glyphicon-arrow-left" \
                        aria-hidden="true"></span> %s' % 'Précédent',
                        type='button',
                        css_class='btn-default btnPrevious',
                    ),
                    StrictButton(
                        '<span class="glyphicon glyphicon-arrow-right" \
                        aria-hidden="true"></span> %s' % 'Suivant',
                        type='button',
                        css_class='btn-default col-md-offset-8 btnNext',
                    )
                ),
                # Troisième onglet
                Tab(
                    # Label de l'onglet
                    'Étape 3 - Validation',
                    # Liste des champs à afficher dont les champs supplémentaires
                    'mail',
                    'confirmation_mail',
                    'comments',
                    'captcha',
                    # Tu rajoutes des boutons "Précédent" et "Valider"
                    StrictButton(
                        '<span class="glyphicon glyphicon-arrow-left" \
                        aria-hidden="true"></span> %s' % "Précédent",
                        type='button',
                        css_class='btn-default btnPrevious',
                    ),
                    StrictButton(
                        '<span class="glyphicon glyphicon-ok" \
                        aria-hidden="true"></span> %s' % "Valider",
                        type='submit',
                        css_class='btn-default col-md-offset-8'
                    )
                ),
            ),
        )

    def clean_confirmation_mail(self):
        """
        Méthode pour vérifier que le mail correspond bien au
        mail de confirmation lors de la validation du formulaire
        """
        confirmation_mail = self.cleaned_data['confirmation_mail']
        mail = self.cleaned_data['mail']
        if mail != confirmation_mail:
            raise forms.ValidationError(
                "Le mail et le mail de confirmation ne sont pas identiques")
        return confirmation_mail

    class Meta:
        # Tu définis le modèle utilisé
        model = Registration
        exclude = []
        # Tu customises le champ date de naissance pour ajouter le date picker
        widgets = {
            'birth_date': DateTimePicker(
                options={"format": "DD/MM/YYYY", "pickTime": False,
                         "useStrict": True, "viewMode": "years",
                         "startDate": "01/01/1900"},
                attrs={'placeholder': 'ex: 05/11/1975'}
            )
        }

4) Les vues

Maintenant que tu as ton formulaire, il te faut une vue pour afficher le formulaire et une autre pour afficher un message de confirmation après la validation de celui-ci.

Tu vas créer tout ça dans apps/core/views.py:

from django.views.generic.edit import CreateView
from .models import Registration
from django.core.urlresolvers import reverse_lazy
from django.shortcuts import render
from .forms import RegistrationForm


class RegistrationCreate(CreateView):
    """
    Affichage du formulaire
    """
    model = Registration
    form_class = RegistrationForm
    success_url = reverse_lazy('core:success')


def registration_success(request):
    """
    Message de confirmation
    """
    return render(request, 'core/registration_success.html')

5) Les urls

Dans le fichier des urls du projet, tu vas inclure les urls de l'application core et l'url pour le captcha.

Dans urls.py, tu insères:

from django.conf.urls import url, include
from django.contrib import admin
from .apps.core.urls import urlpatterns as core_urls

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^', include(core_urls, namespace='core')),
    url(r'^captcha/', include('captcha.urls')),
]

Et dans apps/core/urls.py, tu mets les urls correspondantes à tes deux vues:

from django.conf.urls import patterns, url
from .views import RegistrationCreate, registration_success

urlpatterns = [
    url(r'^$', RegistrationCreate.as_view(), name='add'),
    url(r'^success/$', registration_success, name='success'),
]

6) Les templates

Tu vas créer trois templates:

Le premier, base.html, qui servira de base aux deux autres.
Le deuxième, core/registration_form.html, pour afficher le formulaire.
Le dernier, core/registration_success.html, pour afficher le message de confirmation.

Le template apps/core/templates/base.html va contenir:

<!DOCTYPE html>
<html lang="fr">
<head>
    <title>Mon site</title>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <link rel="stylesheet"
          href="//cdn.jsdelivr.net/bootstrap/3.3.6/css/bootstrap.min.css">
    <link rel="stylesheet"
          href="//cdn.jsdelivr.net/bootstrap/3.3.6/css/bootstrap-theme.min.css">
    <script src="//cdn.jsdelivr.net/jquery/2.2.3/jquery.min.js"></script>
    {% block head-javascript %}{% endblock %}
</head>
<body>
    <div class="container" role="main">
    <div id="summary">
        <div class="page-header">
            {% block page-header %}{% endblock %}
        </div>
    </div>
    {% block content %}
    {% endblock %}
    </div>
    <script src="//cdn.jsdelivr.net/bootstrap/3.3.6/js/bootstrap.min.js"></script>
    {% block foot-javascript %}{% endblock %}
</body>
</html>

C'est une page html5 standard, qui contient les fichiers nécessaires à bootstrap, un block page-header pour afficher le titre de la page et un block content pour afficher le contenu de la page. Les templates suivants vont donc étendre base.html.

Pour le template apps/core/templates/core/registration_form.html, tu mets:

{% extends "base.html" %}
{% load crispy_forms_tags %}

{% block head-javascript %}
    {{ form.media }}
{% endblock %}

{% block page-header %}
<h1>Inscription</h1>
{% endblock %}

{% block content %}
<div class="row">{% crispy form %}</div>
{% endblock %}

{% block foot-javascript %}
<script>
$( document ).ready( function() {
    // On interdit le copier/coller du mail
    $('#id_confirmation_mail').bind('copy paste', function(e) {
        e.preventDefault();
    });
    // On affiche le calendrier lorsqu'on clique sur le champ date de naissance
    $('#id_birth_date').click(function(){
        $(this).parent().data("DateTimePicker").show();
    });
    // On teste la valeur de la date et on la force à vide si elle est mauvaise
    $('#id_birth_date').change(function(e){
        e.preventDefault();
        e.stopPropagation();
        var val = $(this).val();
        var format = new RegExp("^\\d{2}\/\\d{2}\/\\d{4}$");
        if(!format.test(val)) {
            $(this).val("");
        }
    });
    // Afficher l'onglet suivant en cliquant sur le bouton suivant
    $('.btnNext').click(function(){
        $('.nav-tabs > .active + li a').trigger('click');
        $(".nav-tabs + .tab-content").find(":input:visible:first").focus();
    });
    // Afficher l'onglet précédent en cliquant sur le bouton précédent
    $('.btnPrevious').click(function(){
        $('.nav-tabs > .active').prev('li').find('a').trigger('click');
        $(".nav-tabs + .tab-content").find(":input:visible:first").focus();
    });
});
</script>
{% endblock %}

Pour crispy-forms, il ne faut que deux éléments ! Le {% load crispy_forms_tags %}, qui permet d'utiliser le {% crispy form %} pour afficher le formulaire.

Et c'est tout ! Plutôt cool non ?

Le {{ form.media }} est nécessaire au date picker et tout ce qui se trouve dans le block foot-javascript permet de pousser un peu plus la customisation.

Enfin, de la même manière, tu crées le template apps/core/templates/core/registration_success.html:

{% extends "base.html" %}

{% block page-header %}
<h1>Succès</h1>
{% endblock %}

{% block content %}
<div class="row">Votre inscription a été validée.</div>
{% endblock %}

7) La page d'administration

Pour pouvoir vérifier les futures inscriptions, tu ajoutes le modèle Registration dans apps/core/admin.py:

from django.contrib import admin
from .models import Registration


class RegistrationAdmin(admin.ModelAdmin):
    list_display = ('birth_name', 'last_name', 'first_name')

admin.site.register(Registration, RegistrationAdmin)

Tu vas également en profiter pour ajouter un compte admin via:

./manage.py createsuperuser

8) La vérification

Tout est fini ! Il ne reste plus qu'à vérifier que ça fonctionne correctement.

Tu démarres le serveur:

./manage.py runserver

Puis, tu te rends sur http://127.0.0.1:8000 pour tester ton formulaire !

Après avoir correctement saisie et validé le formulaire, rends-toi sur http://127.0.0.1:8000/admin/core/registration/ pour vérifier ton inscription.

Tu sais désormais utiliser un outil puissant pour générer tes nombreux formulaires ! Et pour voir le résultat final, tu peux te rendre sur mon dépôt github.

Environnement de développement open source

2016-04-19T00:00:00+02:00

Envie de faire évoluer ton environnement de développement ?
D'utiliser une solution simple, pratique et efficace ?
Alors, tu es au bon endroit !

On va faire le tour des outils indispensables pour mettre ça en place. Bien évidemment, mon avis est subjectif et ce n'est qu'une solution parmis tant d'autres.

C'est parti !

1) La distro

On commence par le choix de la distribution. Je te conseille vivement de partir sur arch linux pour les raisons suivantes:

rolling-release: ton système est tout le temps à jour et tu bénéficies des dernières versions des logiciels.
légèreté: l'installation de base est minimaliste, ce qui fait que tu n'installes que ce dont tu as besoin.
la communauté: le wiki et le forum de la communauté sont vraiment très bien foutus. Il y a même une communauté francophone.
AUR: c'est un dépôt communautaire où l'on trouve absolument tout.

Les principales critiques envers arch linux concernent en général la stabilité du système. La stabilité, c'est bien pour un serveur. Mais ce n'est pas forcément le plus important pour le poste de travail d'un dev. Avec arch, tu pourras tester les toutes dernières versions des logiciels et utiliser les nouvelles librairies à la mode !

Pour l'installer, je t'invites à le faire à la main en suivant la doc officielle, histoire d'entrer dans le bain. Si tu as vraiment la flemme, tu peux passer par architect pour te faciliter la chose.

N'oublie pas d'installer yaourt pour bénifier du dépôt AUR.

Tu auras remarqué que les tutos de ce blog sont en général à destination des utilisateurs ubuntu/debian. Pas de panique, il te suffira grosso-modo de remplacer les apt-get install par pacman -S pour installer les paquets. Pour le reste, c'est généralement du pareil au même.

2) Le shell

Maintenant, tu vas t'installer un shell très pratique appelé zsh, qui permet une complétion avancée et l'utilisation d'une syntaxe plus sympa que bash pour les scripts.

Et en plus de zsh, tu vas également t'installer tmux, qui est un multiplexeur de terminaux. Il permet de manipuler plusieurs terminaux au sein d'une même fenêtre et de se rattacher à une session tmux distante. C'est très pratique pour le travail collaboratif et pour lancer des commandes sur des serveurs.

pacman -S zsh tmux
exec zsh
chsh -s /bin/zsh

Il ne te reste plus qu'à customiser ton .zshrc comme bon de semble.

3) Le gestionnaire de fenêtre

Oublie les kde, gnome et autres cinammon. Ces environnements sont très bien pour un usage classique de linux ; mais pour du dev, il vaut mieux se tourner vers un tiling window manager.

Je te conseille de partir sur i3, qui est facile d'accès, customisable et efficace. Il te permettra d'utiliser l'ensemble de l'espace visible disponible, de splitter tes fenêtres comme bon te semble et d'exécuter tes applications. De plus, tu pourras manipuler tout ton bureau au clavier, ce qui fait un sacré gain de temps.

pacman -S i3
echo "exec i3" > ~/.xinitrc
reboot

A côté d'i3, tu pourras installer entre autres:

i3-style: pour styliser i3.
dmenu: pour avoir un lanceur d'applications.
i3bar et i3status: pour avoir une barre de status en bas de l'écran.
i3lock et xautolock: pour verrouiller l'écran au bout de quelques minutes d'inactivité.
nitrogen: pour changer l'image de fond.
pactl de pulseaudio: pour changer le volume au clavier.
dunst: pour les notifications.
redshift: pour éviter de se fatiguer les yeux.
pcmanfm: pour la gestion des fichiers.
firefox: pour la navigation web.

Jete un coup d'oeil à ma customisation si ça t'intéresse.

Et si tu as besoin d'aide, la communauté reddit est très active.

4) Je veux coder !

Pour coder, tu auras besoin d'un éditeur de texte. Je te recommande fortement atom, que j'ai déjà présenté ici.

En plus d'atom, tu auras besoin d'un éditeur qui peut s'exécuter dans un terminal. Pas besoin de chercher bien loin, le plus avancé est vim. Mais tu peux également te tourner vers son successeur, neovim.

Comme le reste des outils présentés sur cet article, il est aussi très fortement customisable.

En plus des éditeurs de texte, il te faudra un gestionnaire de version de code. Sans surprise, je t'invite à installer git, qui te permettra de partager ton code sous github et qui s'interface très bien avec atom.

pacman -S git vim
yaourt -S atom

Enfin, à toi d'installer ce qui te manque: python, node.js, postgresql, nginx, etc ...

5) Environnements isolés

Dans le cas où tu aurais besoin de tester des applications sous d'autres distributions, tu pourras utiliser vagrant pour installer des vms ou docker pour utiliser des conteneurs.

yaourt -S vagrant docker docker-compose

A l'aide de docker-compose, tu pourras te créer un environnement spécifique par application en utilisant des conteneurs. Par exemple, un pour elasticsearch, un autre pour mysql, un troisième pour redis et un quatrième pour ton application django.

Tu bénificieras ainsi d'environnements complètement isolés, sans devoir installer des tonnes d'applications directement sur ton système.

A toi de jouer maintenant, et n'hésite pas à donner tes propres astuces dans les commentaires !

Servir une application web python avec chaussette, circus et nginx

2016-04-09T00:00:00+02:00

Voilà, tu as enfin développé ton application django/bottle/flask (raye les mentions inutiles) et tu es fin prêt à la rendre disponible au monde entier.

Mais comment faire ? Quel serveur wsgi utiliser ? A l'aide !

Il existe différentes alternatives, mais je vais te proposer celle que j'affectionne tout particulièrement, à savoir le trio chaussette/circus/nginx.

1) Créer une application web

Tu vas commencer par créer une application bottle de base (pour changer de django, tiens !).

Tu crées et actives un environnement virtuel myapp en python 3.5 à l'aide de virtualenvwrapper:

mkdir myproject && cd myproject
mkvirtualenv -p /usr/bin/python3.5 myapp

Tu installes bottle dans ton virtualenv:

pip install bottle

Dans le répertoire de ton projet, tu crées un module python myapp qui contient un fichier vide __init__.py et un fichier wsgi.py:

mkdir myapp && touch myapp/__init__.py myapp/wsgi.py

Ton fichier wsgi.py doit ressembler à ça:

from bottle import route, template, default_app

@route('/hello/<name>')
def index(name):
    return template('<b>Hello {{name}}</b>!', name=name)

application = default_app()

Pour information, sous django, le fichier à utiliser s'appelle aussi wsgi.py.

2) Installer chaussette et waitress

Maintenant, tu vas utiliser chaussette pour lancer ton application web.

Chaussette est un serveur wsgi qui permet le dialogue entre les requêtes http et ton application python. Il autorise l'utilisation de différents backends wsgi, comme waitress par exemple, et a également la particularité de pouvoir servir ton application sur un socket déjà ouvert. Dis comme ça, ça n'a l'air de rien, mais ça permet du coup d'utiliser un manager de sockets comme circus ou supervisor.

Tu installes chaussette et waitress en étant dans le virtualenv myapp:

pip install chaussette waitress

Et tu lances ton serveur wsgi depuis le répertoire de ton projet myproject:

chaussette --backend waitress myapp.wsgi.application

Rends-toi sur http://127.0.0.1:8080/hello/you, tu devrais voir ta page apparaître. Si tout est ok, tu peux couper chaussette et passer à la suite.

3) Configurer circus

Place au spectacle !

Circus est, grosso-modo, un manager de processus et de sockets compatible python 2 et python 3. C'est lui qui va se charger de monitorer et de redémarrer tes applications. Il permet d'utiliser les virtualenvs et se marie très bien avec chaussette. Ce projet nous vient à l'origine de la fondation mozilla.

Tu l'installes via pip en dehors du virtualenv myapp (donc en global sur ton système):

deactivate
apt-get install libzmq-dev libevent-dev
pip install circus

Et tu crées le fichier de configuration de circus circus.ini dans ton home par exemple. C'est là que tu vas pouvoir configurer tes watchers, qui vont lancer tes processus chaussette.

Dans le fichier ~/circus.ini, tu mets:

[circus]
statsd = 1
httpd = 0

[watcher:myapp]
cmd = /home/TONUSER/.virtualenvs/myapp/bin/chaussette --fd $(circus.sockets.web) --backend waitress myapp.wsgi.application
working_dir = /home/TONUSER/LECHEMINVERSTONPROJET/myproject
numprocesses = 3
copy_env = 1
use_sockets = 1
virtualenv = /home/TONUSER/.virtualenvs/myapp
virtualenv_py_ver = 3.5

[socket:web]
host = 127.0.0.1
port = 8001

N'oublie pas de modifier les différents chemins de working_dir, cmd et virtualenv pour que ça correspondent à ta propre machine. Tu peux également configurer plusieurs watchers si tu souhaites monitorer plusieurs applications web.

Enfin, tu lances le daemon de circus:

circusd --daemon ~/circus.ini

Si tout s'est bien passé, tu devrais pouvoir utiliser la commande circusctl pour voir le statut de tes applications, les redémarrer et autres. Sinon, tu peux exécuter circusd sans l'option --daemon pour debugger.

Tu peux voir ci-dessous quelques exemples d'utilisation de circusctl:

circusctl --help # voir l'ensemble des commandes disponibles
circusctl status # voir le statut des applications
circusctl listsockets # lister les sockets utilisés par les applications
circusctl restart myapp # redémarrer myapp
circusctl reload myapp # recharcher la configuration du watcher myapp

Rends-toi sur http://127.0.0.1:8001/hello/you pour vérifier que tout fonctionne.

Grâce à circus, tu peux désormais manager plusieurs applications différentes, qui tournent sous des environnements virtuels différents.

Pour information, il existe une interface web pour monitorer circus appelé circus-web, mais qui n'est pas encore compatible python 3.

3) Paramétrer nginx

Bon, il ne te reste plus qu'à mettre en place nginx. C'est un serveur http libre et performant qui est une très bonne alternative à apache. Il va nous permettre de transmettre les requêtes http à circus/chaussette via les sockets.

Tu l'installes via apt-get par exemple:

apt-get install nginx

Et tu vas créer la configuration suivante dans /etc/nginx/sites-available/myapp.conf:

upstream myapp  {
    server 127.0.0.1:8001;
}
server {
    listen 80;
    server_name localhost;

    location / {
        proxy_pass      http://myapp$request_uri;
        proxy_redirect  off;
        proxy_set_header   Host             $host;
        proxy_set_header   X-Real-IP        $remote_addr;
    }
}

Tu actives ta conf', tu supprimes le site par défaut et tu redémarres nginx:

ln -s /etc/nginx/sites-available/myapp.conf /etc/nginx/sites-enabled/myapp
rm /etc/nginx/sites-enabled/default
service nginx restart #ou via systemd selon ta distro

Il ne te reste plus qu'à te rendre sur http://localhost/hello/you pour observer le résultat !

Créer une application django minimaliste

2016-04-04T00:00:00+02:00

Django est un framework très complet, qui nécessite un certain investissement pour entrer dans le bain.

Il est donc le plus souvent utilisé pour créer des applications conséquentes, ce qui amène les développeurs à préférer des frameworks légers comme Bottle ou Flask pour le développement de petites applications.

Pourtant, il est possible d'utiliser Django de manière minimaliste, afin d'obtenir un résultat proche des frameworks légers.

L'astuce décrite ci-dessous est à garder quelque part dans un coin de ta tête, car ça pourra sûrement t'être utile un jour.

Après avoir installé django (1.9.5 à l'heure où j'écris ces lignes):

pip install django

Tu crées le fichier myserver.py suivant dans le répertoire de ton pojet:

# -*- coding: utf-8 -*-

"""
    Django minimaliste
"""

from django.conf import settings
from django.conf.urls import url
from django.shortcuts import render
import sys

# On définit les settings obligatoires et utiles
settings.configure(
    DEBUG=True,
    SECRET_KEY='S3CR3T',
    ROOT_URLCONF=__name__,
    TEMPLATES=[{
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': ['./templates/'],
    }],
    MIDDLEWARE_CLASSES=(
        'django.middleware.common.CommonMiddleware',
        'django.middleware.csrf.CsrfViewMiddleware',
        'django.middleware.clickjacking.XFrameOptionsMiddleware',
    ),
)

# On crée nos vues
def index(request, someone="World"):
    return render(request, 'index.html', {"someone": someone})

# On délare nos urls
urlpatterns = (
    url(r'^$', index),
    url(r'^(?P<someone>\w+)/$', index),
)

# On exécute le serveur comme s'il s'agissait d'un fichier manage.py
# via python myserver.py runserver
if __name__ == "__main__":
    from django.core.management import execute_from_command_line
    execute_from_command_line(sys.argv)

Tu as donc écrit:

Les paramètres de configuration de base, incluant le nom du répertoire qui contiendra les templates.
Une vue index qui appelle le template index.html.
Les patterns de tes urls.
Le main qui va te permettre d'exécuter l'ensemble des commandes django.

Evidemment, tu peux faire évoluer ce fichier selon tes besoins, comme pour rajouter une base de données par exemple.

Maintenant, tu vas créer le template index.html suivant dans un sous-répertoire appelé templates:

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title>Hello World!</title>
    </head>
    <body>
        <p>Hello {{ someone }} !</p>
    </body>
</html>

Il ne te reste plus qu'à lancer le serveur via la commande:

python myserver.py runserver

Enfin, rends-toi sur http://127.0.0.1:8000/ et http://127.0.0.1:8000/arthur/ pour voir le résultat !

Programmation fonctionnelle avec PyToolz

2016-03-03T00:00:00+01:00

PyToolz est un ensemble de fonctions qui étendent itertools et functools de la librairie standard. Ainsi, il va te permettre d'utiliser les paradigmes de la programmation fonctionnelle en python.

Ce qui est sympa avec PyToolz, c'est qu'il est écrit en pur python et ne dépend donc d'aucune librairie externe. De plus, il est compatible python 3.

Comme le veut la programmation fonctionnelle, les fonctions proposées sont composable, pure et lazy. Si tout ça ne te parle pas, je t'invite à lire le livre "Apprendre Haskell vous fera le plus grand bien !" pour te plonger dans l'univers de la programmation fonctionnelle. Même si tu ne comptes pas développer en Haskell, il est intéressant d'en comprendre les concepts.

Mais retournons à PyToolz. Comme d'hab, tu l'installes avec pip:

pip install toolz

Et tu peux maintenant utiliser toutes les méthodes de Itertoolz, Functoolz et Dictoolz.

Itertoolz te permettra, par exemple, de retirer les éléments pairs d'une liste:

>>> from toolz.itertoolz import remove
>>> list(remove(lambda x: x % 2 == 0, [1, 2, 3, 4, 5]))
[1, 3, 5]

De récupérer les deux premiers éléments d'une liste:

>>> from toolz.itertoolz import take
>>> list(take(2, [1, 2, 3, 4, 5]))
[1, 2]

De partitionner une liste d'éléments en liste de tuples de deux éléments:

>>> from toolz.itertoolz import partition
>>> list(partition(2, [1, 2, 3, 4, 5]))
[(1, 2), (3, 4)]

Ou encore de retourner les différences entre deux listes:

>>> from toolz.itertoolz import diff
>>> list(diff(["pommes", "poires", "bananes"], ["pommes", "poires", "oranges"]))
[('bananes', 'oranges')]

PyToolz propose également la version curryfiée des différentes fonctions pour en effectuer des applications partielles. Ici, on crée les fonctions remove_even et take_two:

>>> from toolz.curried import remove, take
>>> remove_even = remove(lambda x: x % 2 == 0)
>>> list(remove_even([1, 2, 3, 4, 5]))
[1, 3, 5]
>>> take_two = take(2)
>>> list(take_two([1, 2, 3, 4, 5]))
[1, 2]

Et maintenant, place au fun avec functoolz ! Comme en shell, tu vas pouvoir piper tes fonctions. Disons que tu veuilles les deux premiers éléments non paires d'une liste:

>>> from toolz.curried import remove, take
>>> from toolz.functoolz import pipe
>>> remove_even = remove(lambda x: x % 2 == 0)
>>> take_two = take(2)
>>> list(pipe([1,2,3,4,5], remove_even, take_two))
[1, 3]

Plutôt cool non ?

Dictoolz, quand à lui, permet entre autres de fusionner des dictionnaires:

>>> from toolz.dicttoolz import merge
>>> merge({1: 'one'}, {2: 'two'})
{1: 'one', 2: 'two'}

Ou d'appliquer une fonction aux valeurs d'un dictionnaire:

>>> from toolz.dicttoolz import valmap
>>> bills = {"Alice": [20, 15, 30], "Bob": [10, 35]}
>>> valmap(sum, bills)
{'Alice': 65, 'Bob': 45}

Il y a évidemment tout un tas d'autres fonctions disponibles que je t'invite à découvrir !

Sinon, si tu veux pousser une peu plus loin la programmation fonctionnelle avec python, il existe un langage intéressant appelé Mochi, dont l'interpréteur convertit le code Mochi en bytecode Python 3.

Il permet d'écrire notamment ce genre de chose:

def fizzbuzz(n):
    match [n % 3, n % 5]:
        [0, 0]: "fizzbuzz"
        [0, _]: "fizz"
        [_, 0]: "buzz"
        _: n

range(1, 31)
|> map(fizzbuzz)
|> pvector()
|> print()

À découvrir !

Retour du FOSDEM 2016

2016-02-04T00:00:00+01:00

Le FOSDEM est un événement qui a lieu chaque année à l'Université Libre de Bruxelles. Il permet de rencontrer d'autres développeurs, d'animer et d'assister à des conférences, de partager des idées et des bières, et de découvrir les nouvelles technos sympas du moment.

Cette année, c'était noir de monde ! Plus de 7900 développeurs et sysadmins étaient présents !

Je vais te faire un bref petit retour des confs qui m'ont marqué et des technos à suivre.

Systemd

par Lennart Poettering

Ça y est, systemd est officiellement installé par défaut dans toutes les plus grosses distros linux (sauf gentoo).

Si tu es sous linux, tu vas obligatoirement devoir te pencher dessus. C'est grosso-modo un daemon qui va te permettre de gérer tes services (apache, postgres et autres) via la commande systemctl.

Je ne vais pas m'éterniser dessus, car il y a déjà pas mal d'articles sur le sujet, comme celui-ci.

Docker for developers

par Michael Hrivnak

Bon, n'y allons pas par quatres chemins, docker est clairement LA techno en vogue du moment. La salle était pleine à craquer, et il y avait facilement autant de gens à l'intérieur qu'à l'extérieur. J'avais l'impression que les organisateurs ne s'attendaient pas à ça !

C'est un outil écrit en go et développé par Solomon Kykes, qui permet de gérer des conteneurs LXC et d'y déployer des applications.

On a pu voir ici l'utilisation quotidienne de docker pour un développeur, sans évoquer les questions de déploiement.

Note : on me chuchote à l'oreille que vagrant-lxc pourrait également faire l'affaire. À méditer donc !

Pour les tests unitaires

L'idée, c'est d'utiliser une image docker pour chaque combinaison d'environnements. En python, on a déjà les virtualenvs qui nous permettent de tester diverses combinaisons d'interpréteurs et de librairies python via tox.

Grâce à docker, on va en plus pouvoir tester nos applications dans différents environnements linux (debian, gentoo, etc...).

Il suffit de créer un Dockerfile qui va :

utiliser la bonne distro.
installer les paquets systèmes et les paquets python nécessaires.
monter notre code dans /code par exemple.
exécuter les tests unitaires depuis le conteneur.

Pour la base de données de dev

En utilisant des conteneurs pour tes bases de données, tu peux facilement tester une migration de postgres 9.4 en 9.5 par exemple, sans pourrir ton système. Tu démarres un nouveau conteneur postgres 9.5, tu y fais tes tests de migration et tu la détruis, tout simplement.

Tes tests unitaires pourront également utiliser une base de données dans un conteneur, ce qui te permettra d'éviter de manipuler du sqlite ou une base en mémoire.

Pour diffuser une application de démo

Ce n'est pas forcément évident de containeriser une application de prod. Il faut notamment penser à la gestion des mots de passe et des certificats.

Mais pour diffuser une application de démo, tu peux passer outre ces questions ! Tu vas ainsi éviter à tes utilisateurs d'installer toute une application sur leur système, en leur proposant juste de démarrer un conteneur.

Pour les serveurs http

L'idée est la même que pour les bases de données. Tu peux installer et tester nginx, apache et lighttpd dans des conteneurs.

Pour faker des API

À la place de mocker les réponses de tes API dans tes tests unitaires, tu peux déployer tes API de test dans un conteneur et les utiliser directement dans tes tests unitaires.

Guix-tox

par Cyril Roelandt

Guix est un gestionnaire fonctionnel de paquets pour le système GNU.

Il fonctionne pour tous les langages. Ainsi, il permettrait d'éviter d'utiliser des gestionnaires de paquets spécifiques aux langages, comme pip, npm, cpan.

Il utilise le langage guile, qui est une implémentation de scheme.

Dans guix, on a entre autres la possibilité d'utiliser des conteneurs, de gérer des profils, de revenir en arrière.

Je t'invite à lire l'article de Matutine qui explique bien l'idée générale.

Et du coup, guix-tox est tout simplement un fork de tox qui remplace les virtualenvs python par guix.

Tu vas ainsi pouvoir tester ton application dans un environnement système complet, ce qui rejoint l'idée précédemment évoquée avec docker.

Le débat entre guix, docker et vagrant reste ouvert !

Pulp

par Michael Hrivnak

Pulp est un projet qui permet de gérer ses propres dépôts. On va ainsi pouvoir héberger son propre pypi, synchroniser les dépôts entre eux et y uploader nos paquets.

C'est compatible avec les paquets debian, rpm, python, docker et autres. Franchement, ça semble plutôt bien foutu et pratique!

Pour finir, merci à toute l'équipe du FOSDEM et à l'année prochaine !

Se passer de Grunt/Gulp/Brunch/Broccoli/Mimosa/Jake grâce à Make

2016-01-12T00:00:00+01:00

La communauté Node.js a été plutôt productive ces deux dernières années, notamment au niveau de la création de tasks runners.

Certains sont enthousiastes de cet essor et de cette profusion d'outils, mais d'autres le sont beaucoup moins et le font savoir.

Tu as forcément déjà lu un article ou vu un bout de code qui mentionnait au choix grunt, gulp, brunch, broccoli, mimosa, jake ou que sais-je.

Mais lequel utiliser ? Pourquoi y en a-t-il autant ? Quel est le plus simple ? Le plus performant ? Le plus suivi ? Quel tuto suivre ?

Franchement, devoir ré-apprendre un tasks runners tous les trois mois en fonction de la mode, c'est plutôt lourd. Et ça rappelle fortement le choix cornélien du framework ou de la librairie javascript ( angular, angular2, react, polymer, jquery, vue.js, etc...)

N'y a-t-il pas un outil robuste, simple et pérenne ? Et qui pourrait te servir pour autre chose que du développement frontend tant qu'à faire ? Et ben si, ça existe depuis la création de GNU en 1983 par Richard Stallman, et ça s'appelle Make.

Make est un outil qui permet d'automatiser la construction de fichiers et qui peut jouer le rôle de tasks runners.

Concrètement, en développement web, de quoi est-ce qu'on a le plus besoin ?

Compiler nos fichiers LESS ou Sass en CSS.
Minifier nos fichiers CSS.
Compiler nos fichiers LiveScript, CoffeeScript ou TypeScript en JavaScript.
Minifier nos fichiers JavaScript.
Avoir un watcher qui lance automatiquement toutes ces tâches lorsqu'un fichier source est modifié.

On suppose que tu as :

tes fichiers LESS dans static/src/less
tes fichiers LiveScript dans static/src/ls

Et que tu veux tes fichiers compilés et minifiés dans static/dist/css et static/dist/js.

C'est parti, tu vas te créer un fichier Makefile qui fera tous ça !

vim Makefile

Tu y déclares tes répertoires de travail :

LESS_FOLDER := static/src/less
LS_FOLDER := static/src/ls
CSS_FOLDER := static/dist/css
JS_FOLDER := static/dist/js

Ensuite, tu y listes les fichiers concernés :

LESS_FILES := ${shell find ${LESS_FOLDER} -type f -name '*.less'}
LS_FILES := ${shell find ${LS_FOLDER} -type f -name '*.ls'}
CSS_FILE := ${CSS_FOLDER}/main.min.css
JS_FILE := ${JS_FOLDER}/main.min.js

La commande find utilisée pour LESS_FILES et LS_FILES permet de récupérer le chemin de tous les fichiers LESS et LiveScript présents.

Tu déclares une tâche build qui sera chargée de lancer la compilation des fichiers :

build: build-css build-js

Puis, tu commences par créer la tâche qui va compiler les fichiers LESS :

build-css: ${CSS_FOLDER} ${CSS_FILE}

${CSS_FILE}: ${LESS_FILES}
    cat $^ | lessc - | cleancss > $@

${CSS_FOLDER}:
    mkdir -p $@

Ta tâche build-css va créer le répertoire static/dist/css via mkdir. Et elle va compiler tous les fichiers LESS à l'aide de lessc et les minifier à l'aide de cleancss.

Dans une Makefile, $^ correspond à la liste des dépendances. Il s'agit ici des fichiers contenus dans LESS_FILES. $@ correspond au nom de la cible, à savoir le fichier contenu dans CSS_FILE.

De la même manière, tu crées la tâche qui va compiler les fichiers LiveScript :

build-js: ${JS_FOLDER} ${JS_FILE}

${JS_FILE}: ${LS_FILES}
cat $^ | lsc -sc | uglifyjs - > $@

${JS_FOLDER}:
mkdir -p $@

Les fichiers LiveScript sont compilés à l'aide de lsc et minifiés à l'aide de uglifyjs.

Tu rajoutes une méthode pour nettoyer le répertoire dist :

clean:
    rm ${CSS_FILE} ${JS_FILE}

Et une méthode qui te permettra d'installer les librairies utilisées par ton Makefile via npm :

install-dependencies:
    sudo npm install -g less clean-css livescript uglifyjs onchange

Enfin, tu vas mettre en place ton watcher à l'aide de onchange :

watch:
    onchange "${LESS_FILES}" "${LS_FILES}" -- make build

La dernière instruction servira à dire à make que certaines tâches ne sont pas directement liées à des noms de fichiers :

.PHONY: build build-css build-js clean watch install-dependencies

Et c'est fini! Tu disposes désormais des commandes suivantes :

make install-dependencies : pour installer les dépendances.
make ou make build : pour compiler et minifier tous les fichiers.
make build-js : pour compiler et minifier les fichiers LiveScript.
make build-css : pour compiler et minifier les fichiers LESS.
make clean : pour effacer les fichiers compilés et minifiés.
make watch : pour relancer automatiquement la commande make build à chaque modifications de fichiers.

Le résultat final :

#################################################
# Compile and minify less and livescript files. #
# Require node.js and npm                       #
#################################################

LESS_FOLDER := static/src/less
LS_FOLDER := static/src/ls
CSS_FOLDER := static/dist/css
JS_FOLDER := static/dist/js

LESS_FILES := ${shell find ${LESS_FOLDER} -type f -name '*.less'}
LS_FILES := ${shell find ${LS_FOLDER} -type f -name '*.ls'}
CSS_FILE := ${CSS_FOLDER}/main.min.css
JS_FILE := ${JS_FOLDER}/main.min.js

###############
# Build files #
###############

build: build-css build-js

####################
# Build css files #
####################

build-css: ${CSS_FOLDER} ${CSS_FILE}

${CSS_FILE}: ${LESS_FILES}
    cat $^ | lessc - | cleancss > $@

${CSS_FOLDER}:
    mkdir -p $@

##################
# Build js files #
##################

build-js: ${JS_FOLDER} ${JS_FILE}

${JS_FILE}: ${LS_FILES}
    cat $^ | lsc -sc | uglifyjs - > $@

${JS_FOLDER}:
    mkdir -p $@

###############
# Clean files #
###############

clean:
    rm ${CSS_FILE} ${JS_FILE}

########################
# Install dépendencies #
########################

install-dependencies:
    sudo npm install -g less clean-css livescript uglifyjs onchange

###############
# Watch files #
###############

watch:
    onchange "${LESS_FILES}" "${LS_FILES}" -- make build

#########
# Phony #
#########

.PHONY: build build-css build-js clean watch install-dependencies

Evidemment, ça reste un exemple très simple. Mais rien ne t'empêche de faire évoluer ton Makefile selon tes besoins.

En plus, tu viens d'apprendre un outil qui te sera utile pour faire de l'administration système.

Bonne compilation !

Templating avec Mako

2015-12-23T00:00:00+01:00

Python is a great scripting language. Don't reinvent the wheel... your templates can handle it !

Je suis tombé sur mako suite à une discussion mouvementée au sujet de django et de jinja avec un de mes collègues pro groovy/grails.

Ça devait ressembler à quelque-chose comme ça:

- Rhhaaa je déteste jinja, j'suis obligé d'me taper la doc pour apprendre toute la syntaxe! En plus c'est grave limité! Y a pas moyen d'y écrire directement du python ?
- Bah ça va, c'est pas trop compliqué, et si t'as besoin d'utiliser des méthodes python, tu peux utiliser les custom filters et custom tags!
- Uai mais c'est pas super pratique, avec grails tu peux directement mettre du groovy dans tes templates, c'est génial blablabla
- Ok ok j'ai compris, jinja te convient pas, mais j'suis sûr que ce que tu cherches existe dans la communauté python! Voyons voir ... regardes, y a un truc là, ça s'appelle mako!
- *Yeux qui brillent*

Mako est un moteur de template utilisé dans le framework pyramid, à l'instar de jinja utilisé dans django. Il est réputé pour sa performance, et est même utilisé pour l'affichage des pages de reddit!

Mais son principal atout est de pouvoir utiliser directement du python à l'aide des balises <% %> dans les templates.

Certains diront que c'est pas génial, car on peut vite obtenir des templates assez crades avec tout et n'importe quoi dedans. D'autres diront que ça ne sert à rien d'inventer une nouvelle syntaxe spécifique aux templates, alors que python est disponible et peut faire ça très bien.

Pour te faire ton propre avis, installes-le via pip:

pip install mako

En résumé, tes templates ressembleront à ça:

<%inherit file="base.html"/>
<%
    rows = [[v for v in range(0,10)] for row in range(0,10)]
%>
<table>
    % for row in rows:
        ${makerow(row)}
    % endfor
</table>

<%def name="makerow(row)">
    <tr>
    % for name in row:
        <td>${name}</td>\
    % endfor
    </tr>
</%def>

La syntaxe de mako est très bien expliquée dans la doc officielle, mais pour faire simple :

La substitution d'expressions utilise le symbole ${}, à la manière de perl.
Tu disposes de filtres comme sous jinja, via une syntaxe type ${"this is some text" | u}
Il y a les structures de contrôle classiques % if et % else et les boucles avec % for.
Divers tags sont disponibles comme <%inhérit/>, <%page/>, <%include/>, etc ...
Tu peux rajouter des commentaires avec ##.
Enfin, tout ce qui se trouve entre <% %> est du python. Tu peux profiter de toute la syntaxe de python et même importer des libs. C'est la fête !

Et pour l'utiliser, rien de plus simple, tu utilises la classe Template :

from mako.template import Template

mytemplate = Template("hello, ${name}!")
print(mytemplate.render(name="jack"))

Tu peux désormais utiliser mako pour gérer tes pages html! Et si tu es un utilisateur de django, il t'es même possible de remplacer jinja par mako via django-mako-plus.

En dehors des pages html, tu peux également l'utiliser pour générer d'énormes fichiers XML simples, comme une liste d'utilisateurs par exemple. Ça évite de manipuler le DOM en mémoire comme avec lxml, c'est plus facile d'accès que SAX, et c'est très performant :

from mako.template import Template
from mako.runtime import Context

tpl_xml = '''
<doc>
% for i in data:
<p>${i}</p>
% endfor
</doc>
'''

tpl = Template(tpl_xml)

with open('output.xml', 'w') as f:
    ctx = Context(f, data=xrange(10000000))
    tpl.render_context(ctx)

Httpie, le client http intuitif

2015-12-08T00:00:00+01:00

Httpie est un client http en ligne de commande plutôt bien foutu. C'est une alternative viable à curl qui a été développée en python.

Intuitif, simple, et prenant en charge la coloration syntaxique, c'est l'outil idéal pour requêter des APIs JSON par exemple.

Tu l'installes avec pip :

pip install httpie

Tu disposes maintenant de la commande http dans ton terminal qui te permettra d'effectuer des requêtes très simplement de cette manière:

http [flags] [METHOD] URL [ITEM [ITEM]]

Tu peux évidemment faire du GET:

http httpie.org
http GET httpie.org

Du DELETE:

http DELETE example.org/todos/7

Ou mettre à jour les données d'une API via PUT:

http PUT example.org X-API-Token:123 name=John

Tu remarques ici qu'on a d'abord passé la méthode PUT, puis l'url, puis le token d'authentification dans l'entête de la requête, et enfin les données.

Pas besoin d'utiliser des options pour spécifier chaque élément, tout se fait intuitivement ! Les éléments de l'entête de la requête sont séparés par :, les données par =.

Tu peux aussi utiliser l'option -a pour l'authentification type username/password.

Par exemple, pour poster un commentaire sur un problème via l'api github:

http -a USERNAME POST https://api.github.com/repos/jkbrzt/httpie/issues/83/comments body='HTTPie is awesome!'

Tu peux utiliser les symboles de redirection pour uploader ou downloader des fichiers :

http example.org < file.json
http example.org > file.json

L'outil est très complet (gestion des sessions, des certificats SSL) mais je l'apprécie surtout pour son côté simple et facile d'accès.

Tu vas pouvoir manipuler et tester tes APIs très rapidement, sans te prendre la tête avec une documentation imbuvable!

Ajouter un captcha dans un formulaire django

2015-11-28T00:00:00+01:00

Suite à l'article sur django-countries, on va continuer notre parcours des petits outils simples et efficaces pour améliorer nos formulaires django.

Avant d'aborder le gros morceau qu'est django-cryspy (tu peux déjà y jeter un oeil si tu es curieux), on va parler de l'intégration de captchas sous django.

L'api de captcha la plus connue est sûrement reCAPTCHA de google, et il en existe une implémentation sous django baptisée django-recaptcha.

Mais tu ne veux peut-être pas dépendre d'un service google pour diverses raisons, en préférant une solution autonome, simple, légère, efficace et maintenue.

Django-simple-captcha remplit haut la main toutes ces conditions et est même compatible python 3. Elle est customisable, s'intègre dans les formulaires django et sous django-crispy. Différents types de captcha sont disponibles comme des caractères aléatoires, des calculs mathématiques, des dictionnaires de mots.

Captcha utilise PIL et Pillow qui nécessitent certaines librairies systèmes. Par exemple sous Ubuntu, tu fais:

apt-get -y install libz-dev libjpeg-dev libfreetype6-dev

Tu l'installes comme d'habitude avec pip:

pip install django-simple-captcha

Et tu ajoutes captcha dans la liste de tes INSTALLED_APPS dans le fichier settings.py de django:

INSTALLED_APPS = (...,
                  captcha
)

Tu synchronises ta base de données:

python manage.py migrate

Et tu ajoutes l'entrée suivante dans ton fichier urls.py:

urlpatterns += patterns('',
    url(r'^captcha/', include('captcha.urls')),
)

Il ne reste plus qu'à l'intégrer dans ton formulaire.

Soit dans un Form:

from django import forms
from captcha.fields import CaptchaField

class CaptchaTestForm(forms.Form):
    myfield = AnyOtherField()
    captcha = CaptchaField()

Soit dans un ModelForm:

from django import forms
from captcha.fields import CaptchaField

class CaptchaTestModelForm(forms.ModelForm):
    captcha = CaptchaField()
    class Meta:
        model = MyModel

Et sous django-crispy, tu peux utiliser captcha comme un Field à déclarer dans le Layout:

from django import forms
from captcha.fields import CaptchaField
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Field, Submit

class CaptchaTestModelForm(forms.ModelForm):
    captcha = CaptchaField()

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()

        self.helper.layout = Layout(
            Field('name', placeholder="Enter Full Name"),
            Field('captcha ', placeholder="Enter captcha"),
            Submit('valid', 'Valid')
            )

    class Meta:
        model = MyModel

La validation du formulaire se fait comme d'habitude. Si la réponse au captcha est mauvaise, une exception ValidationError sera levée:

def some_view(request):
    if request.POST:
        form = CaptchaTestForm(request.POST)

        # Validate the form: the captcha field will automatically
        # check the input
        if form.is_valid():
            human = True
    else:
        form = CaptchaTestForm()

    return render_to_response('template.html',locals())

Il est également possible de faire une validation via ajax.

Il y a toute une série de paramètres permettant la customisation du captcha, mais il y en a surtout deux à retenir.

Le premier permet de choisir le type de captcha que tu veux utiliser. Dans ton settings.py, tu peux mettre au choix:

# Random chars
CAPTCHA_CHALLENGE_FUNCT = 'captcha.helpers.random_char_challenge'
# Simple Math
CAPTCHA_CHALLENGE_FUNCT = 'captcha.helpers.math_challenge'
# Dictionary Word
CAPTCHA_CHALLENGE_FUNCT = 'captcha.helpers.word_challenge'

Tu peux même créer ta propre fonction de captcha si celles proposées ne te conviennent pas.

Le second permet d'utiliser le captcha dans les tests unitaires. Si la chaîne de caractères PASSED est renseignée comme valeur de réponse au captcha, le formulaire sera valide. À mettre dans ton fichier de configuration de tes tests unitaires:

CAPTCHA_TEST_MODE = True

Le résultat final ressemble à ça :

Upsert avec Postgresql

2015-11-22T00:00:00+01:00

Lorsque l'on commence à s'amuser avec asyncio pour faire des traitements asynchrones sur une base postgresql avec aiopg, on rencontre assez vite le problème des accès concurrents à une ressource partagée.

Et notamment lorsqu'il s'agit d'appliquer de multiples insert ou update, appelés upsert dans le monde de mongodb.

Sous mongodb avec pymongo c'est facile, il suffit de passer le paramètre upsert=True à la méthode update_one :

>> from pymongo import MongoClient
>> client = MongoClient()
>> db = client.test_database
>> db.test.update_one({'x': 1}, {'$inc': {'x': 3}}, upsert=True)

Mais sous posgresql, il n'existe pas de mot-clé upsert. Et c'est là que tu te demandes:

"Comment faire un upsert en postgresql, tout en évitant les problèmes d'accès concurrents ?"

Si tu n'es pas pressé, attends la sortie de postgresql 9.5 qui va inclure la syntaxe du upsert.

En imaginant une table qui ressemble à ça:

SELECT username, logins FROM user_logins;

username | logins
----------+--------
James    |      4
Lois     |      2
(2 rows)

Et que tu veuilles ajouter deux nouveaux logins:

INSERT INTO user_logins (username, logins)
VALUES ('Naomi',1),('James',1);

En temps normal, tu auras cette erreur si le username existe déjà en base:

ERROR:  duplicate key value violates unique constraint "users_pkey"
DETAIL:  Key (username)=(James) already exists.

Et bien en 9.5, tu pourras gérer ça de cette manière:

INSERT INTO user_logins (username, logins)
VALUES ('Naomi',1),('James',1)
ON CONFLICT (username)
DO UPDATE SET logins = user_logins.logins + EXCLUDED.logins;

Génial non ?

"Oui mais bon, de mon côté, en production, j'ai du postgresql 9.4 et c'est pas près de changer."

Dans ce cas-là, je t'invite à lire ce très bon article qui date un peu, mais qui résume très bien la situation.

Pour rester simple, l'idée est d'effectuer un update si l'entrée existe déjà ou un insert sinon. Mais lors d'accès concurrents, il se peut très bien que l'entrée ait été ajoutée par un autre processus entre ta tentative ratée d'update et ton insert qui suit. Et là, ça plante lamentablement.

Alors oui, il existe les locks et les transactions, mais çe n'est pas suffisant et ça peut poser certains problèmes. Par exemple, postgresql stoppe une transaction en cours lorsqu'il rencontre une erreur. Pour plus de détail, lis l'article que j'ai cité précédemment.

Du coup, la solution admise par la communauté stackoverflow est la suivante. Tu écris une fonction pl/sql qui boucle sur le update ou insert, en utilisant l'exception unique_violation. Du coup, cette fonction s'appelle à l'aide d'un seul select, donc pas besoin de lock ou de transaction:

CREATE TABLE db (a INT PRIMARY KEY, b TEXT);

CREATE FUNCTION merge_db(key INT, data TEXT) RETURNS VOID AS
$$
BEGIN
    LOOP
        -- first try to update the key
        -- note that "a" must be unique
        UPDATE db SET b = data WHERE a = key;
        IF found THEN
            RETURN;
        END IF;
        -- not there, so try to insert the key
        -- if someone else inserts the same key concurrently,
        -- we could get a unique-key failure
        BEGIN
            INSERT INTO db(a,b) VALUES (key, data);
            RETURN;
        EXCEPTION WHEN unique_violation THEN
            -- do nothing, and loop to try the UPDATE again
        END;
    END LOOP;
END;
$$
LANGUAGE plpgsql;

SELECT merge_db(1, 'david');
SELECT merge_db(1, 'dennis');

Introduction à Asyncio

2015-11-15T00:00:00+01:00

La librairie Asyncio a fait beaucoup parler d'elle dernièrement, au point d'être intégrée dans la bibliothèque standard depuis la version 3.4 de Python.

C'est la réponse aux goroutines de Go, inscrivant ainsi Python dans la liste des langages permettant la programmation asynchrone. Ce type de programmation permet de ne pas bloquer son programme lors des opérations I/O qui peuvent durer un certain temps et de réagir lors de la réception des informations au lieu de les attendre. Ça permet ainsi d'optimiser et d'améliorer fortement les performances de son code.

Je t'invite à te renseigner sur les différences entre programmation asynchrone, parallèle et concurrente via l'article de Sam&Max et la vidéo de Jonathan Worthington du monde Perl.

Asyncio utilise une boucle d'événements qui va contenir l'ensemble de nos tâches à exécuter. Ces tâches devront être sous la forme de coroutines, qui sont des sortes de générateurs inversés, c'est-à-dire qu'on y envoie des données à la place d'en reçevoir. C'est le côté lazy des coroutines qui permet à Asyncio de les exécuter en asynchrone.

Trêve de blabla et passons à la pratique. Il y a déjà beaucoup d'articles sur le net traitant du fonctionnement d'Asyncio et ce n'est pas forcément facile de s'y retrouver. Tu vas donc voir ici un cas d'usage concret, qui est le développement d'un aggrégateur de données json performant. Le tutorial sera en python 3.5, ce qui te permettra d'utiliser les nouveaux mots clés async et await.

Tu utiliseras la boucle d'événements, les coroutines et les objets Future. L'idée n'est pas de faire le code le plus simple et performant possible, mais plutôt de passer en revue l'ensemble des concepts et mots-clés utiles.

Pour Asyncio, il n'y a rien à installer à part python 3.5. Par contre, il va te falloir aiohttp pour faire les requêtes http:

pip install aiohttp

Et c'est là où le bât blesse. Tu ne pourras pas utiliser requests par exemple, car il faut utiliser des outils compatibles avec Asyncio, c'est-à-dire écrits sous forme de coroutines. Sinon, le programme bloquera la boucle d'événements et ça ne sera pas asynchrone. Pareil pour les accès BDD, il faut utiliser aiopg pour postgresql par exemple.

Tu crées un fichier asyncio35.py, tu importes aiohttp et asyncio et tu déclares ta liste d'urls:

import asyncio
import aiohttp

URLS = ['http://ip.jsontest.com/', 'http://headers.jsontest.com/',
        'http://date.jsontest.com/']

Tu vas alors créer ta coroutine qui va récupérer les données renvoyées par une url et les insérer dans un objet Future:

async def call_url(client, url, future):
    """ Coroutine récupérant les données provenant d'une url """
    async with client.get(url) as response:
        result = await response.json()
        future.set_result(result)

Plusieurs explications sont nécessaires ici:

async: Nouveau mot-clé introduit en python 3.5, à mettre avant le def, qui permet de spécifier que cette méthode est une coroutine asynchrone. Ça vient remplacer le @asyncio.coroutine de python 3.4.
async with: Permet d'utiliser des context managers asynchrones.
await: Bloque l'exécution de la coroutine jusqu'à la fin du traitement de l'instruction, ici response.json(). Ça vient remplacer le yield from de python 3.4.
future.set_result: Définit la valeur de l'objet Future.

Ensuite, dans ton main, tu initalises ta boucle, ton client aiohttp, ta liste de tâches et ta liste de résultats:

if __name__ == "__main__":
    # On initialise les variables
    list_results, list_tasks = [], []
    loop = asyncio.get_event_loop()
    client = aiohttp.ClientSession(loop=loop)

Tu ajoutes ton callback pour les objets Future:

def fill_results_list(future):
    """ Callback de l'objet future qui ajoute sa valeur dans une liste """
    list_results.append(future.result())

Pour chaque url, tu vas:

créer un objet Future.
ajouter la méthode call_url à la liste des tâches à accomplir via la méthode ensure_future.
ajouter ton callback fill_results_list à ton objet Future via la méthode add_done_callback.

# On créé les objets Future et la liste des tâches
for url in URLS:
    future = asyncio.Future()
    list_tasks.append(asyncio.ensure_future(call_url(client, url, future)))
    future.add_done_callback(fill_results_list)

Puis, il suffit de lancer l'exécution des tâches de manière asynchrone via la boucle d'événements et sa méthode run_until_complete. Ton programme sera bloqué ici jusqu'à la fin du traitement de toutes les tâches et donc de la réception des objets Future via asyncio.wait. À la fin, il affiche la liste des résultats sur la sortie standard:

# Exécution des tâches
loop.run_until_complete(asyncio.wait(list_tasks))
print(list_results)

Enfin, tu peux fermer le client aiohttp et la boucle d'événements:

# Ferme le client et la boucle
client.close()
loop.close()

Encore une chose concernant la boucle. Celle-ci est unique pour tout le programme. Donc il faut faire attention quand tu la manipules à plusieurs endroits du code, et quand tu la fermes.

Voici le résultat final :

import asyncio
import aiohttp

"""
Aggrégation de données provenant d'urls
"""

URLS = ['http://ip.jsontest.com/', 'http://headers.jsontest.com/',
        'http://date.jsontest.com/']

async def call_url(client, url, future):
    """ Coroutine récupérant les données provenant d'une url """
    async with client.get(url) as response:
        result = await response.json()
        future.set_result(result)

if __name__ == "__main__":
    # On initialise les variables
    list_results, list_tasks = [], []
    loop = asyncio.get_event_loop()
    client = aiohttp.ClientSession(loop=loop)

    def fill_results_list(future):
        """ Callback de l'objet future qui ajoute sa valeur dans une liste """
        list_results.append(future.result())

    # On créé les objets Future et la liste des tâches
    for url in URLS:
        future = asyncio.Future()
        list_tasks.append(asyncio.ensure_future(call_url(client, url, future)))
        future.add_done_callback(fill_results_list)

    # Exécution des tâches
    loop.run_until_complete(asyncio.wait(list_tasks))
    print(list_results)

    # Ferme le client et la boucle
    client.close()
    loop.close()

Et hop, tu exécutes tout ça:

$ time python asyncio35.py
[{'ip': '109.221.53.120'},
{'Host': 'headers.jsontest.com', 'User-Agent': 'Python/3.5 aiohttp/0.18.4', 'Accept': '*/*', 'Content-Length': '0'},
{'date': '11-14-2015', 'time': '03:16:45 PM', 'milliseconds_since_epoch': 1447514205836}]

real        0m0.511s
user        0m0.263s
sys 0m0.033s

"Ok c'est sympa mais est-ce que c'est vraiment plus rapide en asynchrone ?"

Tu veux une preuve ? En voici une; le même programme sans Asyncio:

import requests

"""
Aggrégation de données provenant d'urls
"""

URLS = ['http://ip.jsontest.com/', 'http://headers.jsontest.com/',
        'http://date.jsontest.com/']

if __name__ == "__main__":
    list_results = []
    for url in URLS:
        result = requests.get(url)
        list_results.append(result.json())

    print(list_results)

Tu l'exécutes:

$ time python noasyncio35.py
[{'ip': '109.221.53.120'},
{'Host': 'headers.jsontest.com', 'User-Agent': 'python-requests/2.8.1', 'Accept': '*/*'},
{'date': '11-14-2015', 'time': '11:57:03 AM', 'milliseconds_since_epoch': 1447502223337}]

real        0m1.188s
user        0m0.247s
sys 0m0.017s

Le double de temps ! Convaincu ?

Alors évidemment, ce n'est qu'un simple cas d'usage. Il y a beaucoup, mais vraiment beaucoup plus à voir dans la doc officielle.

TinyDB, la base de données pure python

2015-11-06T00:00:00+01:00

TinyDB, ce n'est pas la base de données qui va tout révolutionner, mais c'est le petit outil sympa à avoir à portée de main.

Elle est orientée document, comme MongoDB, en se basant sur des fichiers JSON.

Le code est écrit en pure python, sans besoin d'aucune dépendance, et est compatible python 2 et 3.

Niveau utilisation, il ne faut pas espérer des perfs de malade ; ce n'est pas fait pour ça.

Par contre, si tu as besoin d'une mini BDD pour afficher des news sur un site, ça fera l'affaire.

Personnellement, je l'utilise plutôt lors de la rédaction de tests unitaires, lorsque j'ai besoin d'une batterie de données de test.

Pour l'utiliser, tu l'installes via pip:

pip install tinydb

Tu crées, par exemple, une base de données contenant des légumes:

>>> from tinydb import TinyDB
>>> db = TinyDB('meslegumes.json')

Le fichier meslegumes.json correspond à ta base de données et s'est créé dans le répertoire courant.

Tu crées alors une table legumes. Évite les caractères spéciaux dans le nom de la table, ça peut poser problème:

>>> table = db.table('legumes')

Tu vas maintenant insérer des légumes via la méthode insert:

>>> table.insert({'type': 'carotte', 'nombre': 5})
>>> table.insert({'type': 'patate', 'nombre': 6})
>>> table.insert({'type': 'navet', 'nombre': 2})

En affichant tous les éléments de ta table, tu verras tes légumes:

>>> table.all()
[{u'nombre': 5, u'type': u'carotte'},
 {u'nombre': 6, u'type': u'patate'},
 {u'nombre': 2, u'type': u'navet'}]

Tu peux désormais utiliser un langage de requête. Par exemple, si tu veux récupérer toutes les carottes:

>>> from tinydb import where
>>> table.search(where('type') == 'carotte')
[{u'nombre': 5, u'type': u'carotte'}]

Ou tous les légumes qui sont plus de deux:

>>> table.search(where('nombre') > 2)
[{u'nombre': 5, u'type': u'carotte'}, {u'nombre': 6, u'type': u'patate'}]

Tu peux utiliser le ET et le OU logique, pour combiner tes requêtes lors de ta recherche de légumes:

>>> table.search((where('nombre') > 2) & (where('nombre') < 6))
[{u'nombre': 5, u'type': u'carotte'}]
>>> table.search((where('nombre') < 3) | (where('nombre') > 5))
[{u'nombre': 6, u'type': u'patate'}, {u'nombre': 2, u'type': u'navet'}]

Tu peux évidemment mettre à jour tes navets:

>>> table.update({'nombre': 10}, where('type') == 'navet')
>>> table.search(where('type') == 'navet')
[{u'nombre': 10, u'type': u'navet'}]

Et supprimer tes carottes:

>>> db.remove(where('type') == 'carotte')
>>> table.all()
[{u'nombre': 6, u'type': u'patate'}, {u'nombre': 10, u'type': u'navet'}]

Ou carrément vider tous tes légumes:

>>> table.purge()
>>> table.all()
[]

Voilà pour les bases! Pour un usage simple, ça devrait te suffire.

Il existe d'autres opérations pour le langage de requête comme insert_multiple, delete, increment, decrement, get, contains, count.

Tu peux également stocker les légumes en mémoire à la place du fichier json:

>>> from tinydb.storages import MemoryStorage
>>> db = TinyDB(storage=MemoryStorage)

Et utiliser des middlewares, pour faire du cache par exemple:

>>> from tinydb.storages import JSONStorage
>>> from tinydb.middlewares import CachingMiddleware
>>> db = TinyDB('meslegumes.json', storage=CachingMiddleware(JSONStorage))

Enfin, il est également possible de customiser TinyDB en écrivant ton propre Serializer, ou d'écrire une implémentation YAML pour le stockage des données à la place de JSON, ou encore d'écrire tes propres Middlewares.

Gestion des pays dans django avec django-countries

2015-10-31T00:00:00+01:00

En développement web, on a souvent besoin de faire des formulaires. Et notamment des formulaires d'inscription, avec saisie du nom, prénom, adresse et donc pays.

Tu m'accorderas que laisser le champs pays libre risque de générer des erreurs de saisie, et que gérer manuellement une liste déroulante de pays est ennuyeux à mourir.

Rassure-toi, une solution existe, et c'est là qu'intervient django-countries.

Django-countries, c'est la librairie qui ne paie pas de mine mais qui, l'air de rien, est vachement pratique. Elle propose:

Une liste déroulante pour les formulaires, contenant la liste de tous les pays avec leurs codes iso 3166, traduite dans 25 langues.
Des widgets.
Des fichiers statiques correspondants aux icônes des drapeaux des pays.
Un champ pays pour les modèles.
Une compatibilité avec Django Rest Framework.

Tu l'installes via pip:

pip install django-countries

Et tu ajoutes django_countries dans la liste de tes INSTALLED_APPS dans le fichier settings.py de django.

INSTALLED_APPS = (...,
                  django_countries
)

Au niveau de ton modèle, tu peux maintenant utiliser le champ CountryField, qui est basé sur CharField et qui correspond au code iso 3166:

from django.db import models
from django_countries.fields import CountryField

class Person(models.Model):
    name = models.CharField(max_length=100)
    country = CountryField(blank_label='(select country)')

Tu peux maintenant créer une personne avec un pays associé, et accéder aux différents attributs du pays comme son code, son icône, son nom et autres:

>>> person = Person(name='Chris', country='NZ')
>>> person.country
Country(code='NZ')
>>> person.country.name
'New Zealand'
>>> person.country.flag
'/static/flags/nz.gif'
>>> person.country.alpha3
'NZL'
>>> person.country.numeric
'554'
>>> person.country.numeric_padded
'554'

Dans le formulaire associé à ton modèle, tu peux aussi utiliser un widget qui va afficher le drapeau du pays à côté de la liste déroulante:

from django_countries.widgets import CountrySelectWidget

class PersonForm(forms.ModelForm):
    class Meta:
        model = models.Person
        fields = ('name', 'country')
        widgets = {'country': CountrySelectWidget()}

Dans le settings.py, on peut spécifier les pays à utiliser:

COUNTRIES_ONLY = ['NZ', 'AU']

Ou carrément customiser la liste:

COUNTRIES_OVERRIDE = {
    'NZ': _('Middle Earth'),
    'AU': None
}

Et on a donc également une compatibilité avec Django Rest Framework en modifiant le serializer de cette manière:

class PersonSerializer(serializers.ModelSerializer):
    country = CountryField()

    class Meta:
        model = models.Person
        fields = ('name', 'email', 'country')

Je ne suis pas rentré dans le détail de la customisation pour rester simple, mais il est possible de modifier pas mal de choses au niveau de la liste, du champ, de l'affichage et du paramétrage.

A voir dans la doc officielle si ça t'intéresse!

Intégration continue sous Github avec Tox, Travis, Coveralls et Landscape

2015-10-25T00:00:00+02:00

L'intégration continue est une part très importante d'un projet, à ne surtout pas négliger. Elle permet de vérifier constamment son code via des tests unitaires, généralement à chaque commit. Ceci permet de tester la qualité et la robustesse du code et d'éviter toutes régressions.

Dans cet article, tu verras comment mettre en place l'intégration continue d'une application python sous Github. À la fin de cette lecture, tu seras capable:

d'écrire un test unitaire simple.
de vérifier la couverture de ton code.
d'exécuter tes tests sous plusieurs versions de python.
d'automatiser l’exécution des tests à chaque commit.
d'automatiser la vérification de la couverture du code.
d'automatiser l'analyse de la qualité de ton code.
d'utiliser les badges github pour l'affichage des rapports.

L'application de démo de ce tuto est dispo ici.

1) Créer une application

Dans le répertoire de ton projet myproject, tu vas créer un package myapp contenant le classique __init__.py, ainsi qu'un fichier maths.py. Celui-ci contiendra une méthode d'addition et de soustraction:

# -*- coding: utf-8 -*-

"""
Provides an addition function and a subtraction function
"""


def addition(a, b):
    """ Méthode d'addition """
    return a + b


def subtraction(a, b):
    """ Méthode de soustraction """
    return a - b

Tu vas donc mettre en place l'intégration continue sur ce petit bout de code.

Tu ajoutes également dans le répertoire du projet le fichier setup.py suivant:

#!/usr/bin/env python

from setuptools import setup

setup(name='myproject',
  version='1.0',
  description='My project',
  author='Me',
  author_email='me@noreply.com',
  url='http://myproject',
  packages=[],
  )

Puis, tu exécutes la commande suivante afin d'ajouter ton application dans le path python:

python setup.py develop

2) Ajouter des tests unitaires

Tu vas maintenant créer des tests unitaires à l'aide de unittest.

Au même niveau que ton package myapp, tu vas créer un package tests qui sera dédié aux tests unitaires. Celui-ci doit contenir le fichier __init__.py et le fichier test_maths.py suivant:

# -*- coding: utf-8 -*-
"""
Tests unitaires
"""
from unittest import TestCase, main
from myapp.maths import addition, subtraction


class MathsTest(TestCase):
    """
    Classe qui va contenir nos test unitaires
    """
    def setUp(self):
        """ Méthode qui permet d'initialiser des variables pour nos tests """
        self.a = 25
        self.b = 12

    def test_addition(self):
        """ Test de l'addition """
        self.assertEqual(addition(self.a, self.b), 37)

    def test_subtraction(self):
        """ Test de la soustraction """
        self.assertEqual(subtraction(self.a, self.b), 13)

    def tearDown(self):
        """ Méthode appelée à la fin des tests """
        self.a = None
        self.b = None

if __name__ == '__main__':
    main()

Et pour vérifier le bon fonctionnement de tes tests, tu peux les exécuter via:

python tests/test_maths.py

Pour plus d'informations concernant les tests unitaires, je t'invite à te pencher sur le dossier de Sam&Max :

3) Couvrir son code avec Coverage

Tu vas maintenant ajouter les utilitaires permettant la couverture de ton code.

Premièrement, tu installes coverage:

pip install coverage

Puis, tu crées le fichier de configuration de coverage appelé .coveragerc dans ton répertoire myproject:

[run]
source =
    myapp

[report]
omit = */tests/*

Tu y indiques d'exéctuer les tests de ton application myapp, tout en ignorant d'analyser la couverture des fichiers de tests. Sinon, il faudrait faire des tests unitaires pour tester les tests unitaires !

Tu lances les tests unitaires avec coverage:

coverage run -m unittest discover tests/

Tu peux désormais afficher un rapport simple via:

coverage report

Ou un rapport html via:

coverage html

Celui-ci s'est créé dans le répertoire htmlcov. A l'aide de ce rapport, tu vas pouvoir visualiser le pourcentage de code couvert ainsi que les zones de code couvertes et non couvertes, fichier par fichier. Plutôt pratique non ?

4) Utiliser Tox pour l'exécution des tests

Tox vise à standardiser l'exécution des tests unitaires en python. Il permet, à l'aide d'environnements virtuels, de tester ton code sous plusieurs interpréteurs python et sous plusieurs versions de librairies.

Il est très simple d'utilisation et s’interface parfaitement avec Travis.

Tu peux l'installer via pip:

pip install tox

Ensuite, il te faut créer le fichier tox.ini dans le répertoire myproject:

[tox]
envlist=py27,py34

[testenv]
deps=coverage
commands=coverage run -m unittest discover tests/

Explication:

envlist permet de lister les interpréteurs python que l'on veut tester. Ici, tu vas tester ton application sous python 2.7 et python 3.4. Il faut évidemment les installer sur ton système si ce n'est pas déjà fait.
deps liste les dépendances à installer dans le virtualenv qui sera créé.
commands indique la commande à exécuter pour lancer les tests unitaires.
il y a plein d'autres paramètres utilisables, va voir dans la doc officielle.

Enfin, pour exécuter tes tests sous les différents environnements, lance la commande:

tox

Plutôt simple non ?

Crée-toi un dépôt sur Github et commit tout ça.

5) Activer l'intégration continue de notre projet sous Travis et Coveralls

Travis est un outil d'intégration continue, à la manière de Jenkins. C'est lui qui va exécuter tes tests unitaires à chaque commit, et qui va t'envoyer un mail si un problème a été rencontré.

Tu peux t'y connecter via ton compte Github et y ajouter ton dépôt git via le bouton +.

Au préalable, il faut créer un fichier .travis.yml dans ton répertoire myproject:

language: python
python: "2.7"
env:
- TOX_ENV=py27
- TOX_ENV=py34
install:
- pip install tox
script: tox -e $TOX_ENV
after_success:
- pip install coveralls
- coveralls

On y indique les environnements de tox à tester et le script tox à exécuter.

Tu peux maintenant commiter tout ça sur ton dépôt Github, et te rendre sur le site de travis pour visualiser les rapports d'exécution de tes tests!

"Attends un peu, c'est quoi la partie qui est dans le after_success, coveralls?"

Bien vu! Coveralls est un outil qui permet de tester la couverture de code à chaque commit.

Connecte-toi sur leur plate-forme via ton compte Github et active ton dépôt git via le bouton add repos.

Tu vas ainsi pouvoir voir l'évolution de la couverture de code et analyser les rapports proposés.

6) Inspecter la qualité du code avec Landscape.io

Landscape.io est une plate-forme qui va inspecter la qualité de ton code à chaque commit. Celle-ci est gratuite pour les projets open-source disponibles sur Github.

Elle se base sur flake8 comme outil d'inspection de code.

Connecte-toi sur la plate-forme avec ton compte Github et ajoutes-y ton dépôt git via Add repository.

Tu devras peut-être refaire un commit pour activer le bazar.

7) Ajouter des badges sur github

Tu va pouvoir te créer un fichier README.rst et y ajouter les badges travis, coveralls et landscape. Tu peux trouver ces badges sous différents formats, notamment en restructuredText, dans la configuration de ton projet sur ces trois plate-formes.

Exemple:

demo-integration-continue
-------------------------

Application de démo d'intégration continue sous github

.. image:: https://travis-ci.org/dotmobo/demo-integration-continue.svg
    :target: https://travis-ci.org/dotmobo/demo-integration-continue

.. image:: https://coveralls.io/repos/dotmobo/demo-integration-continue/badge.svg?branch=master&service=github
    :target: https://coveralls.io/github/dotmobo/demo-integration-continue?branch=master

.. image:: https://landscape.io/github/dotmobo/demo-integration-continue/master/landscape.svg?style=flat
    :target: https://landscape.io/github/dotmobo/demo-integration-continue/master
    :alt: Code Health

Commit et rends-toi sur ton dépôt github pour voir le résultat!

Passer de Sublime Text à Atom pour développer en Python

2015-10-17T00:00:00+02:00

"Sublime Text, c'est vraiment pas mal mais bon, c'est pas libre."
"Eclipse, c'est lourd, trop lourd."
"Vim, j'ai pas le temps de m'y investir."
"Emacs, j'y comprends rien."
"Pycharm, ce n'est qu'à moitié gratuit."
"Atom, y paraît que c'est buggé et lent."

Bon, je vois que tu es un difficile concernant le choix de ton éditeur de code, et tu as bien raison ! Je t'arrêtes tout de suite en ce qui concerne Atom. Pour les autres, je ne vais pas rentrer dans le troll!

"C'était" buggé et lent, mais ça ne l'est plus depuis la sortie de la version stable 1.0 cet été. La version actuelle (1.0.19) marche plutôt bien et est enfin devenue une alternative viable à Sublime Text.

Comme ST, tu vas pouvoir bénificier:

des curseurs multiples.
de la palette de commandes via ctrl+shift+p.
de la recherche de fichiers via ctrl+p.
d'une intégration Git très poussée.
d'une vue permettant de parcourir tes fichiers.
d'onglets, de panels.
de la coloration syntaxique, de la complétion.
d'une tonnes de plugins.

Il n'y a évidemment pas encore autant de plugins que pour ST, mais ça vient comme tu peux le voir ici.

Convaincu ? Prêt pour l'installation ? C'est parti.

Installe-le tout d'abord via les paquets proposés sur le site officiel.

Avant de l'exécuter, on va installer une série de plugins qui va te permettre de développer dans de bonnes conditions. Ces plugins vont être:

minimap, qui est un aperçu du code sous forme de minimap à la manière de ST.
autocomplete-paths, qui permet d'activer la complétion des chemins des dossiers et fichiers de ton système.
autocomplete-python, qui est le plugin le plus fiable pour la complétion Python, basé sur jedi. Pour activer la complétion des librairies présentes dans ton virtualenv, il suffit de lancer atom depuis ton virtualenv.
linter, qui permet de visualiser les erreurs de syntaxe de nombreux langages.
linter-flake8 comme linter python. On aurait pu en utiliser un autre, comme linter-pylint, mais je le trouve trop verbeux.
emmet pour le développement HTML et CSS.
git-plus, qui permet d'utiliser toutes les commandes git depuis Atom.
merge-conflicts, qui est un bon helper lors des git merge.
travis-ci-status, pour afficher le status de travis dans la barre de status d'Atom.
monokai, pour obtenir un thème proche de ST.
pigments, pour afficher les couleurs dans les fichiers CSS, LESS et autres.
color-picker, pour choisir une couleur HTML via ctrl+alt+c.
highlight-selected, qui, lors du double-clique sur un mot, met en surbrillance tous les mots correspondants, comme ST.
atom-beautify, qui permet d'indenter automatiquement le code de nombreux langages pour améliorer la lisibilité.
language-restructuredtext, qui active la coloration syntaxique des fichiers .rst.

Il en existe d'autres qui pourrait t'intéresser, comme vim-mode, terminal-plus, ou encore project-manager, à toi de faire ton marché!

Atom propose un outil en ligne de commande, apm, qui permet d'installer des plugins sans passer par le menu Settings d'Atom. On installe donc les plugins:

apm install minimap
apm install autocomplete-paths
pip install jedi
apm install autocomplete-python
apm install linter
pip install flake8
apm install linter-flake8
apm install emmet
apm install git-plus
apm install merge-conflicts
apm install travis-ci-status
apm install monokai
apm install pigments
apm install color-picker
apm install highlight-selected
apm install atom-beautify
apm install language-restructuredtext

Tu peux maintenant lancer Atom via la commande:

atom

On commence par définir la tabulation comme étant 4 espaces pour être compatible pep8 dans Edit->Preferences->Settings:

Tab Length
4

Puis on active le thème Monokai installé précédemment via Edit->Preferences->Theme:

Syntax Theme
Monokai

Et c'est fini! Tout est prêt pour commencer le développement de tes applications Python et Django.

Tu peux alors créer tes propres snippets en éditant le fichier snippets.cson du répertoire ~/.atom de cette manière par exemple:

'.source.js':
  'console.log':
    'prefix': 'log'
    'body': 'console.log(${1:"crash"});$2'

Utilise alt+shift+s pour rechercher tes snippets.

Enfin tu vas également pouvoir sauvegarder ta configuration sur Github de cette manière par exemple.

Générer son site statique grâce à Pelican

2015-10-11T00:00:00+02:00

Pelican est un outil vraiment chouette pour générer rapidement un site statique comme un blog, afin de le publier via Github Pages par exemple.

C'est une alternative Python à Jekyll (qui lui est écrit en Ruby), permettant de rédiger ses articles en Markdown. La principale force de Pelican, c'est de proposer également le reStructuredText comme format d'écriture, ce qui rendra heureux tous les amoureux de Sphinx.

Pour l'installer, rien de plus simple, l'outil est dispo sur Pypi:

pip install pelican

Il propose une commande de génération automatique de projet :

mkdir ~/dev/myblog && cd ~/dev/myblog && pelican-quickstart

N'oublie pas de dire oui aux deux questions concernant Github Pages, et ... c'est tout! Pour proposer des articles, il te suffit de les créer en .rst dans le dossier content:

vi ~/dev/myblog/content/mon-article.rst

Ils devront ressembler à ça:

Mon article
###########

:date: 2015-10-11 10:20
:modified: 2015-11-04 18:40
:tags: python,django
:category: Développement
:slug: mon-article
:authors: Toi
:summary: Mon article concerne blablabla

blablabla ...

Jetons maintenant un coup d'oeil aux deux fichiers de configuration.

Le premier, pelicanconf.py , est utilisé pour la configuration générale du site:

#!/usr/bin/env python
# -*- coding: utf-8 -*- #
from __future__ import unicode_literals

AUTHOR = 'myusername'
SITENAME = "myblog"
SITEURL = ''

PATH = 'content'

TIMEZONE = 'Europe/Paris'

DEFAULT_LANG = 'fr'

# Feed generation is usually not desired when developing
FEED_ALL_ATOM = None
CATEGORY_FEED_ATOM = None
TRANSLATION_FEED_ATOM = None
AUTHOR_FEED_ATOM = None
AUTHOR_FEED_RSS = None

# Blogroll
LINKS = None

# Social widget
SOCIAL = None

DEFAULT_PAGINATION = 10

# Uncomment following line if you want document-relative URLs when developing
RELATIVE_URLS = True

# Theme
# THEME = "simple"

Tu remarqueras une partie Theme, on y reviendra plus tard. Le reste est relativement compréhensible pour se passer d'explication.

Le second, publishconf.py , rajoute les spécificités pour la production:

#!/usr/bin/env python
# -*- coding: utf-8 -*- #
from __future__ import unicode_literals

# This file is only used if you use `make publish` or
# explicitly specify it as your config file.

import os
import sys
sys.path.append(os.curdir)
from pelicanconf import *

SITEURL = 'http://myusername.github.io'
RELATIVE_URLS = False

FEED_ATOM = 'feeds/all.atom.xml'

DELETE_OUTPUT_DIRECTORY = True

# Following items are often useful when publishing

#DISQUS_SITENAME = ""
#GOOGLE_ANALYTICS = ""

Il est important ici de définir SITEURL et FEED_ATOM. En effet, en mode dev, on n'a pas besoin de générer les flux atom et on utilise des urls relatives.

Si besoin, tu noteras une compatibilité avec Google Analytics. Et concernant Disqus, on y reviendra également plus tard.

Pelican propose alors tout un tas de commandes pour générer et déployer ton site. Au choix, on va pouvoir utiliser Fabric (malheureusement non disponible en Python 3) ou make.

Pour générer ton site en mode dev (utilise pelicanconf.py):

make html

Tu peux aussi utiliser un watcher pour automatiser la génération de ton site à chaque modification:

make regenerate

Pour servir ton site en mode dev sur http://localhost:8000/:

make serve

Pour générer ton site pour la production (utilise publishconf.py):

make publish

Enfin, pour le diffuser sur le master de ton dépôt Github Pages:

make github

Concernant le dépôt Github, je te recommande de commiter le code Pelican sur une branche à part, et de garder la branche master pour la diffusion du site. Ton dépôt devra s'appeler <username>.github.io pour être compatbile avec Github Pages.

Par défaut, le design peut sembler austère.

C'est pourquoi on va installer un thème un peu plus moderne utilisant Bootstrap, comme alchemy par exemple.

La plupart des thèmes disponibles sont sous licence MIT, donc n'hésite pas à les forker pour y apporter tes customisations.

Pour les habitués de django et flask, Pelican utilise jinja2 comme moteur de template. Et ça c'est carrément cool.

On installe donc alchemy:

git clone git@github.com:nairobilug/pelican-alchemy.git ~/dev/pelican-alchemy
pelican-themes -i ~/dev/pelican-alchemy/alchemy

Et on définit la variable THEME de notre fichier de conf pelicanconf.py:

THEME = "alchemy"
SITE_SUBTEXT = "Blabla"
PROFILE_IMAGE = "profil.jpeg"
GITHUB_ADDRESS = "https://github.com/myusername"
TWITTER_ADDRESS = "https://twitter.com/myusername"
EXTRA_FAVICON = False
LICENSE_NAME = "MIT"
LICENSE_URL = "https://opensource.org/licenses/MIT"
MENU_ITEMS = {}
META_DESCRIPTION = "Blabla
PAGES_ON_MENU = True
CATEGORIES_ON_MENU = True
TAGS_ON_MENU = True
ARCHIVES_ON_MENU = True
SHOW_ARTICLE_AUTHOR = False

Concernant les paramètres optionnels, je t'invite à regarder la doc d'alchemy.

"Ok, avoir un blog statique, c'est bien sympa, mais comment je fais pour avoir des commentaires? Il me faut bien une partie dynamique non ?". Pas de panique, Disqus est là pour ça.

Il te suffit de te créer un compte sur Disqus et d'y enregistrer ton site en utilisant le paramétrage universal-embed-code. À partir de là, tu vas pouvoir le configurer via http://<username>.disqus.com/admin/settings.

Enfin, tu l'actives via ton fichier de conf de prod publishconf.py:

DISQUS_SITENAME = "myusername"

Tu commites tout ça, tu publies et hop! Ton blog est complètement prêt!

Et si tu veux pousser un peu plus loin l'outil, il y a énormément de plugins disponibles.

Bienvenue, ami(e) développeur(euse)!

2015-10-10T00:00:00+02:00

Tu trouveras sur ce blog tout un tas de trucs concernant le développement en général.

J'y aborderai principalement tout ce qui touche de près ou de loin à l'univers de python et django, en présentant des outils et librairies sympas et des trucs et astuces.

Mais ça ne m’empêchera pas, de temps à autres, de lorgner du côté d'autres langages si je tombe sur d'intéressantes découvertes.

Bonne lecture à tous.