pakdo 0.0.0__tar.gz

pakdo-0.0.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: pakdo
+Version: 0.0.0
+Summary: Une petite animation de goutte d'eau qui tombe, dans le terminal.
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Natural Language :: French
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# pakdo
+
+Une petite bibliothèque Python, sans dépendance, qui affiche dans le terminal
+l'animation d'une goutte d'eau qui tombe puis éclabousse la surface.
+
+```
+               .
+              / \
+              \_/
+
+
+
+               '
+          ( '     ' )
+~~~~~~~~~~(~~~~~~~~~)~~~~~~~~~~
+```
+
+## Installation
+
+```bash
+pip install pakdo==0.0.0
+```
+
+## Utilisation
+
+En ligne de commande :
+
+```bash
+python -m pakdo                 # une chute
+python -m pakdo --boucles 0     # en boucle (Ctrl+C pour arrêter)
+python -m pakdo --largeur 41 --hauteur 20 --fps 30 --sans-couleur
+```
+
+Depuis Python :
+
+```python
+from pakdo import Goutte, animer
+
+animer()                                   # animation par défaut
+Goutte(largeur=41, hauteur=20).jouer(fps=30, boucles=3)
+
+# Récupérer les images pour les afficher ailleurs
+images = Goutte().frames()
+print(images[0])
+```
+
+## Paramètres de `Goutte`
+
+| Paramètre | Défaut | Description                                  |
+|-----------|--------|----------------------------------------------|
+| `largeur` | 31     | nombre de colonnes (minimum 11)              |
+| `hauteur` | 16     | nombre de lignes, surface comprise (min. 6)  |
+| `gravite` | 0.35   | accélération de la chute                     |
+| `couleur` | True   | affichage en bleu (codes ANSI)               |
+
+`jouer(fps=20, boucles=1)` : `boucles=0` répète à l'infini.
+
+## Tests
+
+```bash
+python -m unittest discover tests
+```

pakdo-0.0.0/README.md

@@ -0,0 +1,62 @@
+# pakdo
+
+Une petite bibliothèque Python, sans dépendance, qui affiche dans le terminal
+l'animation d'une goutte d'eau qui tombe puis éclabousse la surface.
+
+```
+               .
+              / \
+              \_/
+
+
+
+               '
+          ( '     ' )
+~~~~~~~~~~(~~~~~~~~~)~~~~~~~~~~
+```
+
+## Installation
+
+```bash
+pip install pakdo==0.0.0
+```
+
+## Utilisation
+
+En ligne de commande :
+
+```bash
+python -m pakdo                 # une chute
+python -m pakdo --boucles 0     # en boucle (Ctrl+C pour arrêter)
+python -m pakdo --largeur 41 --hauteur 20 --fps 30 --sans-couleur
+```
+
+Depuis Python :
+
+```python
+from pakdo import Goutte, animer
+
+animer()                                   # animation par défaut
+Goutte(largeur=41, hauteur=20).jouer(fps=30, boucles=3)
+
+# Récupérer les images pour les afficher ailleurs
+images = Goutte().frames()
+print(images[0])
+```
+
+## Paramètres de `Goutte`
+
+| Paramètre | Défaut | Description                                  |
+|-----------|--------|----------------------------------------------|
+| `largeur` | 31     | nombre de colonnes (minimum 11)              |
+| `hauteur` | 16     | nombre de lignes, surface comprise (min. 6)  |
+| `gravite` | 0.35   | accélération de la chute                     |
+| `couleur` | True   | affichage en bleu (codes ANSI)               |
+
+`jouer(fps=20, boucles=1)` : `boucles=0` répète à l'infini.
+
+## Tests
+
+```bash
+python -m unittest discover tests
+```

pakdo-0.0.0/pakdo/__init__.py

@@ -0,0 +1,6 @@
+"""pakdo — une petite animation de goutte d'eau qui tombe, dans le terminal."""
+
+from .animation import Goutte, animer
+
+__all__ = ["Goutte", "animer"]
+__version__ = "0.0.0"

pakdo-0.0.0/pakdo/__main__.py

@@ -0,0 +1,26 @@
+"""Point d'entrée en ligne de commande : ``python -m pakdo``."""
+
+import argparse
+
+from .animation import Goutte
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="pakdo", description="Animation d'une goutte d'eau qui tombe.")
+    parser.add_argument("--largeur", type=int, default=31, help="largeur de la scène (défaut : 31)")
+    parser.add_argument("--hauteur", type=int, default=16, help="hauteur de la scène (défaut : 16)")
+    parser.add_argument("--gravite", type=float, default=0.35, help="accélération de la chute (défaut : 0.35)")
+    parser.add_argument("--fps", type=float, default=20, help="images par seconde (défaut : 20)")
+    parser.add_argument("--boucles", type=int, default=1, help="nombre de répétitions, 0 = infini (défaut : 1)")
+    parser.add_argument("--sans-couleur", action="store_true", help="désactive la couleur")
+    args = parser.parse_args()
+
+    try:
+        goutte = Goutte(args.largeur, args.hauteur, args.gravite, couleur=not args.sans_couleur)
+        goutte.jouer(fps=args.fps, boucles=args.boucles)
+    except ValueError as e:
+        parser.error(str(e))
+
+
+if __name__ == "__main__":
+    main()

pakdo-0.0.0/pakdo/animation.py

@@ -0,0 +1,162 @@
+"""Génération et lecture de l'animation d'une goutte d'eau qui tombe."""
+
+from __future__ import annotations
+
+import os
+import sys
+import time
+from dataclasses import dataclass
+from typing import Iterator, List, Optional, TextIO
+
+# Dessin de la goutte (3 lignes x 3 colonnes).
+SPRITE_GOUTTE = [
+    " . ",
+    "/ \\",
+    "\\_/",
+]
+
+EAU = "~"
+VIDE = " "
+
+_BLEU = "\033[36m"
+_RESET = "\033[0m"
+_CURSEUR_ACCUEIL = "\033[H"
+_EFFACER_ECRAN = "\033[2J"
+_CACHER_CURSEUR = "\033[?25l"
+_MONTRER_CURSEUR = "\033[?25h"
+
+Grille = List[List[str]]
+
+
+@dataclass
+class Goutte:
+    """Animation d'une goutte qui tombe puis éclabousse la surface de l'eau.
+
+    :param largeur: nombre de colonnes de la scène (minimum 11).
+    :param hauteur: nombre de lignes de la scène, surface de l'eau comprise (minimum 6).
+    :param gravite: accélération de la chute, en lignes par image².
+    :param couleur: affiche l'animation en bleu (codes ANSI).
+    """
+
+    largeur: int = 31
+    hauteur: int = 16
+    gravite: float = 0.35
+    couleur: bool = True
+
+    def __post_init__(self) -> None:
+        if self.largeur < 11:
+            raise ValueError("la largeur doit être au moins 11")
+        if self.hauteur < 6:
+            raise ValueError("la hauteur doit être au moins 6")
+        if self.gravite <= 0:
+            raise ValueError("la gravité doit être strictement positive")
+
+    # ------------------------------------------------------------------ images
+
+    def frames(self) -> List[str]:
+        """Retourne toutes les images de l'animation (chaînes multi-lignes)."""
+        return list(self._chute()) + list(self._eclaboussure())
+
+    def _chute(self) -> Iterator[str]:
+        # La goutte s'arrête juste au-dessus de la surface.
+        fin = self.hauteur - 1 - len(SPRITE_GOUTTE)
+        t = 0
+        while True:
+            y = min(int(0.5 * self.gravite * t * t), fin)
+            grille = self._grille_vide()
+            self._dessiner_sprite(grille, SPRITE_GOUTTE, y, self.largeur // 2 - 1)
+            yield self._rendu(grille)
+            if y >= fin:
+                return
+            t += 1
+
+    def _eclaboussure(self) -> Iterator[str]:
+        cx = self.largeur // 2
+        surface = self.hauteur - 1
+        # (hauteur au-dessus de la surface, caractère) des gouttelettes projetées
+        gouttelettes = {1: (1, "'"), 2: (2, "'"), 3: (2, "."), 4: (1, ".")}
+
+        k = 1
+        while 2 * k - 4 <= cx:
+            grille = self._grille_vide()
+            if k == 1:
+                self._poser(grille, surface - 1, cx - 1, "\\")
+                self._poser(grille, surface - 1, cx + 1, "/")
+            if k in gouttelettes:
+                h, c = gouttelettes[k]
+                self._poser(grille, surface - h, cx - (k + 1), c)
+                self._poser(grille, surface - h, cx + (k + 1), c)
+            for r in (2 * k, 2 * k - 4):
+                if r > 0:
+                    self._poser(grille, surface, cx - r, "(")
+                    self._poser(grille, surface, cx + r, ")")
+            yield self._rendu(grille)
+            k += 1
+
+        # Surface redevenue calme.
+        yield self._rendu(self._grille_vide())
+
+    # ------------------------------------------------------------ utilitaires
+
+    def _grille_vide(self) -> Grille:
+        grille = [[VIDE] * self.largeur for _ in range(self.hauteur - 1)]
+        grille.append([EAU] * self.largeur)
+        return grille
+
+    def _poser(self, grille: Grille, y: int, x: int, c: str) -> None:
+        if 0 <= y < self.hauteur and 0 <= x < self.largeur:
+            grille[y][x] = c
+
+    def _dessiner_sprite(self, grille: Grille, sprite: List[str], haut: int, gauche: int) -> None:
+        for dy, ligne in enumerate(sprite):
+            for dx, c in enumerate(ligne):
+                if c != VIDE:
+                    self._poser(grille, haut + dy, gauche + dx, c)
+
+    @staticmethod
+    def _rendu(grille: Grille) -> str:
+        return "\n".join("".join(ligne) for ligne in grille)
+
+    # ---------------------------------------------------------------- lecture
+
+    def jouer(self, fps: float = 20, boucles: int = 1, sortie: Optional[TextIO] = None) -> None:
+        """Joue l'animation dans le terminal.
+
+        :param fps: images par seconde.
+        :param boucles: nombre de répétitions (0 = infini, arrêt avec Ctrl+C).
+        :param sortie: flux de sortie (``sys.stdout`` par défaut).
+        """
+        if fps <= 0:
+            raise ValueError("fps doit être strictement positif")
+        sortie = sortie or sys.stdout
+        _activer_ansi()
+        images = self.frames()
+        delai = 1 / fps
+
+        sortie.write(_CACHER_CURSEUR + _EFFACER_ECRAN)
+        try:
+            n = 0
+            while boucles <= 0 or n < boucles:
+                for image in images:
+                    if self.couleur:
+                        image = _BLEU + image + _RESET
+                    sortie.write(_CURSEUR_ACCUEIL + image)
+                    sortie.flush()
+                    time.sleep(delai)
+                n += 1
+        except KeyboardInterrupt:
+            pass
+        finally:
+            sortie.write(_RESET + _MONTRER_CURSEUR + "\n")
+            sortie.flush()
+
+
+def _activer_ansi() -> None:
+    """Active l'interprétation des codes ANSI dans la console Windows."""
+    if os.name == "nt":
+        os.system("")
+
+
+def animer(fps: float = 20, boucles: int = 1, **options) -> None:
+    """Raccourci : crée une :class:`Goutte` avec ``options`` et la joue."""
+    Goutte(**options).jouer(fps=fps, boucles=boucles)

pakdo-0.0.0/pakdo.egg-info/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: pakdo
+Version: 0.0.0
+Summary: Une petite animation de goutte d'eau qui tombe, dans le terminal.
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Natural Language :: French
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# pakdo
+
+Une petite bibliothèque Python, sans dépendance, qui affiche dans le terminal
+l'animation d'une goutte d'eau qui tombe puis éclabousse la surface.
+
+```
+               .
+              / \
+              \_/
+
+
+
+               '
+          ( '     ' )
+~~~~~~~~~~(~~~~~~~~~)~~~~~~~~~~
+```
+
+## Installation
+
+```bash
+pip install pakdo==0.0.0
+```
+
+## Utilisation
+
+En ligne de commande :
+
+```bash
+python -m pakdo                 # une chute
+python -m pakdo --boucles 0     # en boucle (Ctrl+C pour arrêter)
+python -m pakdo --largeur 41 --hauteur 20 --fps 30 --sans-couleur
+```
+
+Depuis Python :
+
+```python
+from pakdo import Goutte, animer
+
+animer()                                   # animation par défaut
+Goutte(largeur=41, hauteur=20).jouer(fps=30, boucles=3)
+
+# Récupérer les images pour les afficher ailleurs
+images = Goutte().frames()
+print(images[0])
+```
+
+## Paramètres de `Goutte`
+
+| Paramètre | Défaut | Description                                  |
+|-----------|--------|----------------------------------------------|
+| `largeur` | 31     | nombre de colonnes (minimum 11)              |
+| `hauteur` | 16     | nombre de lignes, surface comprise (min. 6)  |
+| `gravite` | 0.35   | accélération de la chute                     |
+| `couleur` | True   | affichage en bleu (codes ANSI)               |
+
+`jouer(fps=20, boucles=1)` : `boucles=0` répète à l'infini.
+
+## Tests
+
+```bash
+python -m unittest discover tests
+```

pakdo-0.0.0/pakdo.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+pakdo/__init__.py
+pakdo/__main__.py
+pakdo/animation.py
+pakdo.egg-info/PKG-INFO
+pakdo.egg-info/SOURCES.txt
+pakdo.egg-info/dependency_links.txt
+pakdo.egg-info/entry_points.txt
+pakdo.egg-info/top_level.txt
+tests/test_animation.py

pakdo-0.0.0/pakdo.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pakdo-0.0.0/pakdo.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pakdo = pakdo.__main__:main

pakdo-0.0.0/pakdo.egg-info/top_level.txt

@@ -0,0 +1 @@
+pakdo

pakdo-0.0.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pakdo"
+version = "0.0.0"
+description = "Une petite animation de goutte d'eau qui tombe, dans le terminal."
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = []
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Natural Language :: French",
+]
+
+[project.scripts]
+pakdo = "pakdo.__main__:main"
+
+[tool.setuptools]
+packages = ["pakdo"]

pakdo-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pakdo-0.0.0/tests/test_animation.py

@@ -0,0 +1,44 @@
+import io
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from pakdo import Goutte
+
+
+class TestGoutte(unittest.TestCase):
+    def test_toutes_les_images_ont_la_meme_taille(self):
+        g = Goutte(largeur=21, hauteur=10)
+        for image in g.frames():
+            lignes = image.split("\n")
+            self.assertEqual(len(lignes), 10)
+            self.assertTrue(all(len(l) == 21 for l in lignes))
+
+    def test_la_goutte_part_du_haut(self):
+        premiere = Goutte().frames()[0].split("\n")
+        self.assertIn("/ \\", premiere[1])
+
+    def test_la_derniere_image_est_calme(self):
+        g = Goutte(largeur=15, hauteur=8)
+        derniere = g.frames()[-1].split("\n")
+        self.assertTrue(all(l.strip() == "" for l in derniere[:-1]))
+        self.assertEqual(derniere[-1], "~" * 15)
+
+    def test_parametres_invalides(self):
+        with self.assertRaises(ValueError):
+            Goutte(largeur=5)
+        with self.assertRaises(ValueError):
+            Goutte(hauteur=2)
+        with self.assertRaises(ValueError):
+            Goutte(gravite=0)
+
+    def test_jouer_ecrit_dans_la_sortie(self):
+        sortie = io.StringIO()
+        Goutte(couleur=False).jouer(fps=1000, sortie=sortie)
+        self.assertIn("\\_/", sortie.getvalue())
+
+
+if __name__ == "__main__":
+    unittest.main()