simalleles 0.9.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
simalleles/__init__.py ADDED
@@ -0,0 +1,57 @@
1
+ # encode : utf-8
2
+ # Python 3.10
3
+ # ----------------------------------------------------------------------------
4
+
5
+ import re
6
+ from importlib.metadata import PackageNotFoundError, version
7
+ from pathlib import Path
8
+
9
+ from .core.allele import Allele
10
+ from .core.config import SimulationConfig
11
+ from .core.generation import Generation
12
+ from .core.individu import Individu
13
+ from .core.population import Population
14
+ from .core.simulation import Simulation
15
+ from .core.utils import calc_nbr_type_allele, to_purcent
16
+ from .core.world import World
17
+
18
+
19
+ def _read_version() -> str:
20
+ """Lit la version du projet, avec priorité au `pyproject.toml` local.
21
+
22
+ En exécution depuis les sources,
23
+ une ancienne distribution installée dans l'environnement
24
+ ne doit pas masquer la version du dépôt.
25
+ Dans une wheel installée,
26
+ le `pyproject.toml` n'est pas présent
27
+ et les métadonnées `importlib.metadata` sont utilisées.
28
+ """
29
+ pyproject = Path(__file__).resolve().parent.parent / "pyproject.toml"
30
+ if pyproject.is_file():
31
+ match = re.search(
32
+ r'^version\s*=\s*"([^"]+)"',
33
+ pyproject.read_text(encoding="utf-8"),
34
+ re.MULTILINE,
35
+ )
36
+ if match:
37
+ return match.group(1)
38
+ try:
39
+ return version("simalleles")
40
+ except PackageNotFoundError: # pragma: no cover - source sans métadonnées
41
+ return "0.9.0"
42
+
43
+
44
+ __version__ = _read_version()
45
+
46
+ __all__ = [
47
+ "__version__",
48
+ "Allele",
49
+ "Simulation",
50
+ "SimulationConfig",
51
+ "World",
52
+ "Population",
53
+ "Generation",
54
+ "Individu",
55
+ "calc_nbr_type_allele",
56
+ "to_purcent",
57
+ ]
simalleles/__main__.py ADDED
@@ -0,0 +1,8 @@
1
+ # encode : utf-8
2
+ # Python 3.10
3
+ # ----------------------------------------------------------------------------
4
+
5
+ from simalleles.web.__main__ import cli
6
+
7
+ if __name__ == "__main__":
8
+ cli()
@@ -0,0 +1,24 @@
1
+ # encode : utf-8
2
+ # Python 3.10
3
+ # ----------------------------------------------------------------------------
4
+
5
+ from .allele import Allele
6
+ from .config import SimulationConfig
7
+ from .generation import Generation
8
+ from .individu import Individu
9
+ from .population import Population
10
+ from .simulation import Simulation
11
+ from .utils import calc_nbr_type_allele, to_purcent
12
+ from .world import World
13
+
14
+ __all__ = [
15
+ "Allele",
16
+ "Simulation",
17
+ "SimulationConfig",
18
+ "World",
19
+ "Population",
20
+ "Generation",
21
+ "Individu",
22
+ "calc_nbr_type_allele",
23
+ "to_purcent",
24
+ ]
@@ -0,0 +1,44 @@
1
+ # encode : utf-8
2
+ # Python 3.10
3
+ # ----------------------------------------------------------------------------
4
+
5
+ from __future__ import annotations
6
+
7
+
8
+ class Allele:
9
+ """Allèle d'un locus diploïde, caractérisé par sa valeur et son poids.
10
+
11
+ Le poids est utilisé au moment du tirage des gamètes :
12
+ un allèle de poids plus élevé est transmis plus souvent.
13
+ Il ne s'agit pas d'une probabilité et il doit rester strictement positif.
14
+
15
+ Attributes:
16
+ value: Valeur de l'allèle (`"A"` ou `"a"` dans le modèle actuel).
17
+ weight: Poids de transmission utilisé par :meth:`World.choice_allele`.
18
+ """
19
+
20
+ __slots__ = ("value", "weight")
21
+
22
+ def __init__(self, value: str, weight: float = 1.0) -> None:
23
+ """Crée un allèle.
24
+
25
+ Args:
26
+ value: Valeur de l'allèle, par exemple `"A"` ou `"a"`.
27
+ weight: Poids de transmission strictement positif (1.0 par défaut).
28
+ """
29
+ self.value = value
30
+ self.weight = weight
31
+
32
+ def __repr__(self) -> str:
33
+ """Retourne une représentation lisible de l'allèle."""
34
+ return f"Allele(value={self.value!r}, weight={self.weight})"
35
+
36
+ def __eq__(self, other: object) -> bool:
37
+ """Compare deux allèles par valeur et par poids."""
38
+ if not isinstance(other, Allele):
39
+ return NotImplemented
40
+ return self.value == other.value and self.weight == other.weight
41
+
42
+ def __hash__(self) -> int:
43
+ """Rend les allèles utilisables comme clés de dictionnaire ou dans un set."""
44
+ return hash((self.value, self.weight))
@@ -0,0 +1,92 @@
1
+ # encode : utf-8
2
+ # Python 3.10
3
+ # ----------------------------------------------------------------------------
4
+
5
+ from __future__ import annotations
6
+
7
+ from dataclasses import dataclass
8
+
9
+
10
+ @dataclass
11
+ class SimulationConfig:
12
+ """Paramètres validés d'une simulation d'allèles à deux allèles.
13
+
14
+ Les pourcentages (`inceste`, `migration`, `mutation`)
15
+ sont exprimés en points de pourcentage,
16
+ entre 0 et 100 dans l'interface.
17
+ Le moteur les compare à un tirage entier de 1 à 100.
18
+
19
+ Attributes:
20
+ nbr_generations: Nombre de générations à simuler (>= 1).
21
+ nbr_populations: Nombre de populations indépendantes (>= 1).
22
+ nbr_individus: Effectif initial de chaque population (>= 1).
23
+ taux: Nombre d'enfants produits par individu et par génération (> 0).
24
+ inceste: Probabilité, en pourcentage, de choisir un partenaire apparenté.
25
+ migration: Probabilité, en pourcentage, qu'un individu change de population.
26
+ mutation: Probabilité, en pourcentage, qu'un individu subisse une mutation.
27
+ weight_A: Poids de transmission de l'allèle `A` (> 0).
28
+ weight_a: Poids de transmission de l'allèle `a` (> 0).
29
+ allow_AA: Autorise les croisements A/A.
30
+ allow_Aa: Autorise les croisements A/a (dans les deux sens).
31
+ allow_aa: Autorise les croisements a/a.
32
+ seed: Graine du générateur aléatoire ; `None` pour un tirage non reproductible.
33
+ """
34
+
35
+ nbr_generations: int = 10
36
+ nbr_populations: int = 1
37
+ nbr_individus: int = 1000
38
+ taux: float = 1.0
39
+ inceste: int = 0
40
+ migration: int = 0
41
+ mutation: int = 0
42
+ weight_A: float = 1.0
43
+ weight_a: float = 1.0
44
+ allow_AA: bool = True
45
+ allow_Aa: bool = True
46
+ allow_aa: bool = True
47
+ seed: int | None = None
48
+
49
+ def __post_init__(self) -> None:
50
+ """Valide les bornes et la cohérence des paramètres.
51
+
52
+ Raises:
53
+ ValueError: Si un effectif est nul, si le taux ou un poids est
54
+ négatif ou nul, ou si aucun croisement n'est autorisé.
55
+ """
56
+ if self.nbr_populations < 1:
57
+ raise ValueError("nbr_populations doit être >= 1")
58
+ if self.nbr_individus < 1:
59
+ raise ValueError("nbr_individus doit être >= 1")
60
+ if self.nbr_generations < 1:
61
+ raise ValueError("nbr_generations doit être >= 1")
62
+ if self.taux <= 0:
63
+ raise ValueError("taux doit être > 0")
64
+ if self.weight_A <= 0 or self.weight_a <= 0:
65
+ raise ValueError("les poids des allèles doivent être > 0")
66
+ if not (self.allow_AA or self.allow_Aa or self.allow_aa):
67
+ raise ValueError(
68
+ "au moins un croisement parmi A/A, A/a, a/a doit être autorisé"
69
+ )
70
+
71
+ @property
72
+ def weights(self) -> dict[str, float]:
73
+ """Retourne les poids de transmission sous la forme `{"A": ..., "a": ...}`."""
74
+ return {"A": self.weight_A, "a": self.weight_a}
75
+
76
+ @property
77
+ def allele_pairs(self) -> list[tuple[str, str]]:
78
+ """Paires d'allèles utilisées pour construire la génération initiale.
79
+
80
+ Chaque paire représente un génotype possible.
81
+ A/a est ajouté dans les deux ordres
82
+ pour conserver une répartition homogène des hétérozygotes.
83
+ """
84
+ pairs: list[tuple[str, str]] = []
85
+ if self.allow_AA:
86
+ pairs.append(("A", "A"))
87
+ if self.allow_Aa:
88
+ pairs.append(("A", "a"))
89
+ pairs.append(("a", "A"))
90
+ if self.allow_aa:
91
+ pairs.append(("a", "a"))
92
+ return pairs
@@ -0,0 +1,81 @@
1
+ # encode : utf-8
2
+ # Python 3.10
3
+ # ----------------------------------------------------------------------------
4
+
5
+ import random
6
+
7
+ from .individu import Individu
8
+
9
+
10
+ class Generation:
11
+ """Une génération d'individus appartenant à une même population.
12
+
13
+ Attributes:
14
+ females: Individus de sexe féminin.
15
+ males: Individus de sexe masculin.
16
+ population: Population propriétaire, ou `None` pour une génération
17
+ transitoire en cours de construction.
18
+ rng: Générateur aléatoire (`World` ou module `random`).
19
+ """
20
+
21
+ def __init__(
22
+ self,
23
+ count:int = 0,
24
+ *,
25
+ population = None,
26
+ alleles_predefinies = None,
27
+ rng: object = None,
28
+ ):
29
+ """Construit une génération.
30
+
31
+ Args:
32
+ count: Nombre d'individus à créer. Zéro crée une génération vide,
33
+ utile pour recevoir les enfants d'une reproduction.
34
+ population: Population à laquelle rattacher les individus.
35
+ alleles_predefinies: Paires d'allèles imposées pour la génération
36
+ initiale. `None` laisse chaque allèle être tiré au hasard.
37
+ rng: Générateur aléatoire exposant `_choice` ; par défaut le
38
+ module :mod:`random` global.
39
+ """
40
+ # Séparations des individus féminins et masculins
41
+ # dans le but d'optimiser la reproduction,
42
+ # cela évite de vérifier le sexe.
43
+ self.females = []
44
+ self.males = []
45
+
46
+ self.population = population
47
+ self.rng = rng or random
48
+
49
+ if count:
50
+ for _ in range(count):
51
+ if alleles_predefinies:
52
+ Individu(*self.rng._choice(alleles_predefinies), generation=self)
53
+ else:
54
+ Individu(generation=self)
55
+
56
+ def __iter__(self):
57
+ """Itère sur tous les individus, femmes puis hommes."""
58
+ return self.individus
59
+
60
+ @property
61
+ def individus(self):
62
+ """Générateur parcourant les femelles puis les mâles."""
63
+ for i in self.females:
64
+ yield i
65
+ for i in self.males:
66
+ yield i
67
+
68
+ def append(self, i):
69
+ """Ajoute un individu dans la liste correspondant à son sexe."""
70
+ if i.sexe == 'F':
71
+ self.females.append(i)
72
+ if i.sexe == 'M':
73
+ self.males.append(i)
74
+
75
+ def remove(self, i):
76
+ """Retire un individu de la liste correspondant à son sexe."""
77
+ if i.sexe == 'F':
78
+ self.females.remove(i)
79
+ if i.sexe == 'M':
80
+ self.males.remove(i)
81
+
@@ -0,0 +1,102 @@
1
+ # encode : utf-8
2
+ # Python 3.10
3
+ # ----------------------------------------------------------------------------
4
+
5
+ from __future__ import annotations
6
+
7
+ import random
8
+
9
+
10
+ class Individu:
11
+ """Individu diploïde portant deux allèles et un sexe.
12
+
13
+ Attributes:
14
+ generation: Génération à laquelle l'individu appartient.
15
+ allele_1: Premier allèle du génotype.
16
+ allele_2: Second allèle du génotype.
17
+ sexe: `"F"` pour femelle, `"M"` pour mâle.
18
+ parents: Liste des deux parents, vide pour la génération initiale.
19
+ children: Enfants produits par cet individu.
20
+ population: Population courante (utile après une migration).
21
+ old_population: Ancienne population et génération d'origine, renseignée
22
+ lors d'une migration.
23
+ """
24
+
25
+ __slots__ = (
26
+ 'generation',
27
+ 'allele_1',
28
+ 'allele_2',
29
+ 'sexe',
30
+ 'parents',
31
+ 'children',
32
+ 'history',
33
+ 'population',
34
+ 'old_population'
35
+ )
36
+
37
+ def __init__(
38
+ self,
39
+ allele_1:str = None,
40
+ allele_2:str = None,
41
+ sexe:str = None,
42
+ *,
43
+ generation:Generation,
44
+ parents:list = None
45
+ ):
46
+ """Crée un individu.
47
+
48
+ Les allèles et le sexe absents sont tirés au hasard
49
+ via le générateur de la génération.
50
+ Un individu est immédiatement inscrit dans la liste
51
+ des femelles ou des mâles de sa génération.
52
+
53
+ Args:
54
+ allele_1: Premier allèle, ou `None` pour un tirage aléatoire.
55
+ allele_2: Second allèle, ou `None` pour un tirage aléatoire.
56
+ sexe: `"F"` ou `"M"`, ou `None` pour un tirage aléatoire.
57
+ generation: Génération de rattachement (obligatoire).
58
+ parents: Parents de l'individu, vide pour la génération initiale.
59
+ """
60
+ self.generation = generation
61
+
62
+ self.allele_1 = allele_1 or self.generation.rng._choice(['A', 'a'])
63
+ self.allele_2 = allele_2 or self.generation.rng._choice(['A', 'a'])
64
+
65
+ self.sexe = sexe or self.generation.rng._choice(['F', 'M'])
66
+
67
+ if self.sexe == 'F':
68
+ self.generation.females.append(self)
69
+ if self.sexe == 'M':
70
+ self.generation.males.append(self)
71
+
72
+ self.parents = parents or []
73
+ self.children = []
74
+ self.history = []
75
+
76
+ def reproduce_with(self, i, generation=None):
77
+ """Crée un enfant avec un autre individu.
78
+
79
+ Un allèle est tiré dans chacun des deux génotypes parentaux
80
+ via :meth:`World.choice_allele`,
81
+ puis l'enfant est rattaché à `generation`.
82
+ L'enfant est ajouté aux listes `children` des deux parents.
83
+
84
+ Args:
85
+ i: Second parent.
86
+ generation: Génération qui doit recevoir l'enfant.
87
+
88
+ Returns:
89
+ L'individu enfant nouvellement créé.
90
+ """
91
+ choice_allele = self.generation.population.world.choice_allele
92
+
93
+ child = Individu(
94
+ choice_allele(self.allele_1, self.allele_2),
95
+ choice_allele(i.allele_1, i.allele_2),
96
+ generation = generation,
97
+ parents = [self, i]
98
+ )
99
+
100
+ self.children.append(child)
101
+ i.children.append(child)
102
+ return child
@@ -0,0 +1,137 @@
1
+ # encode : utf-8
2
+ # Python 3.10
3
+ # ----------------------------------------------------------------------------
4
+
5
+ from __future__ import annotations
6
+
7
+ from .generation import Generation
8
+
9
+ import random
10
+
11
+
12
+ class Population:
13
+ """Population nommée, constituée d'une suite de générations.
14
+
15
+ Attributes:
16
+ name: Identifiant de la population (`"P1"`, `"P2"`, ...).
17
+ world: Monde qui contient la population et fournit le générateur.
18
+ generations: Historique des générations, de la plus ancienne à la plus récente.
19
+ """
20
+
21
+ def __init__(
22
+ self,
23
+ name:str,
24
+ generation:Generation = None,
25
+ world:World = None
26
+ ):
27
+ """Crée une population et l'enregistre dans son monde.
28
+
29
+ Args:
30
+ name: Nom unique de la population.
31
+ generation: Génération initiale ; elle est obligatoire en pratique.
32
+ world: Monde de rattachement ; il est obligatoire en pratique.
33
+ """
34
+ self.name = name
35
+ self.world = world
36
+ self.generations = [generation] if generation else []
37
+
38
+ generation.population = self
39
+ world.populations[self.name] = self
40
+
41
+ def new_generation(
42
+ self,
43
+ *,
44
+ taux:float = 1.0,
45
+ inceste:int = 0,
46
+ migration:int = 0,
47
+ ):
48
+ """Produit la génération suivante par reproduction des individus.
49
+
50
+ Le nombre d'enfants créés vaut `int(effectif_courant * taux)`.
51
+ Chaque enfant reçoit un allèle de chaque parent.
52
+ Le premier parent est tiré au hasard,
53
+ le second est choisi parmi les individus de sexe opposé
54
+ de la même génération.
55
+
56
+ Args:
57
+ taux: Nombre d'enfants produits par individu (1.0 conserve
58
+ globalement l'effectif).
59
+ inceste: Probabilité, en pourcentage, de chercher le second parent
60
+ dans la famille du premier. Si aucun apparenté n'est disponible,
61
+ la reproduction est ignorée.
62
+ migration: Conservé pour compatibilité ; la migration est appliquée
63
+ en amont par :meth:`World.new_generation`.
64
+
65
+ Returns:
66
+ `None`. La nouvelle génération est ajoutée à l'historique.
67
+ """
68
+ children = Generation(population=self, rng=self.world)
69
+
70
+ individus = list(self.last_generation)
71
+
72
+ try: individus_with_parent = set(
73
+ individus + list(self.generations[-2])
74
+ )
75
+ except:
76
+ individus_with_parent = individus
77
+
78
+ for _ in range(int(len(individus) * taux)):
79
+
80
+ i1 = self.world._choice(individus)
81
+
82
+
83
+ ### Inceste
84
+ #
85
+
86
+ if (
87
+ not inceste
88
+ or self.world._randint(0, 100) > inceste
89
+ or not i1.parents # When first generation
90
+ ):
91
+ if i1.sexe == 'F':
92
+ if not i1.generation.males:
93
+ continue
94
+ i2 = self.world._choice(i1.generation.males)
95
+ if i1.sexe == 'M':
96
+ if not i1.generation.females:
97
+ continue
98
+ i2 = self.world._choice(i1.generation.females)
99
+ else:
100
+ family = [
101
+ i
102
+ for i in set([
103
+ *i1.parents,
104
+ *[c for p in i1.parents for c in p.children]
105
+ ])
106
+ if
107
+ # Permet de vérifier si une personne de sa famille est dans
108
+ # la même population que l'individu,
109
+ # il ne peut pas se reproduire si elle n'est pas là.
110
+ i in individus_with_parent
111
+ and (
112
+ (i1.sexe == 'F' and i.sexe == 'M')
113
+ or
114
+ (i1.sexe == 'M' and i.sexe == 'F')
115
+ )
116
+ ]
117
+
118
+ if not family:
119
+ continue
120
+ else:
121
+ i2 = self.world._choice(family)
122
+
123
+ #
124
+ ###
125
+
126
+ i1.reproduce_with(i2, generation=children)
127
+
128
+ self.add_generation(children)
129
+
130
+ def add_generation(self, individus):
131
+ """Ajoute une génération à l'historique de la population."""
132
+ self.generations.append(individus)
133
+
134
+ @property
135
+ def last_generation(self):
136
+ """Retourne la génération la plus récente."""
137
+ return self.generations[-1]
@@ -0,0 +1,108 @@
1
+ # encode : utf-8
2
+ # Python 3.10
3
+ # ----------------------------------------------------------------------------
4
+
5
+ from __future__ import annotations
6
+
7
+ from .config import SimulationConfig
8
+ from .generation import Generation
9
+ from .population import Population
10
+ from .utils import calc_nbr_type_allele, to_purcent
11
+ from .world import World
12
+
13
+
14
+ class Simulation:
15
+ """Moteur d'exécution d'une simulation d'évolution d'allèles.
16
+
17
+ Les résultats sont retournés sous forme de dictionnaire structuré.
18
+ """
19
+
20
+ def __init__(self, config: SimulationConfig) -> None:
21
+ """Prépare une simulation à partir d'une configuration validée.
22
+
23
+ Args:
24
+ config: Paramètres de la simulation.
25
+ """
26
+ self.config = config
27
+
28
+ def run(self) -> dict[str, list[dict]]:
29
+ """Exécute la simulation et retourne l'historique par population.
30
+
31
+ Structure retournée :
32
+ {
33
+ "P1": [
34
+ {"generation": 0, "a_a": int, "A_A": int, "a_A": int,
35
+ "A_a": int, "pourcentages": (int, int, int)},
36
+ ...
37
+ ],
38
+ ...
39
+ }
40
+ """
41
+ import random
42
+
43
+ rng = random.Random(self.config.seed) if self.config.seed is not None else None
44
+
45
+ world = World(self.config.weights, rng=rng)
46
+
47
+ for i in range(self.config.nbr_populations):
48
+ Population(
49
+ f"P{i + 1}",
50
+ Generation(
51
+ count=self.config.nbr_individus,
52
+ alleles_predefinies=(
53
+ self.config.allele_pairs
54
+ if len(self.config.allele_pairs) != 3
55
+ else None
56
+ ),
57
+ rng=world,
58
+ ),
59
+ world=world,
60
+ )
61
+
62
+ for _ in range(self.config.nbr_generations):
63
+ world.new_generation(
64
+ taux=self.config.taux,
65
+ inceste=self.config.inceste,
66
+ migration=self.config.migration,
67
+ mutation=self.config.mutation,
68
+ )
69
+
70
+ return build_history(world)
71
+
72
+
73
+ def build_history(world: World) -> dict[str, list[dict]]:
74
+ """Convertit un `World` en historique sérialisable (picklable).
75
+
76
+ Le `World` contient des références croisées
77
+ (individu <-> génération <-> population)
78
+ qui ne peuvent pas traverser une frontière de processus.
79
+ L'interface n'a besoin que des comptes par génération.
80
+
81
+ Args:
82
+ world: Monde dont les populations viennent d'être simulées.
83
+
84
+ Returns:
85
+ Un dictionnaire `population -> liste de générations` ne contenant que
86
+ des types simples (entiers et tuples).
87
+ """
88
+ history: dict[str, list[dict]] = {}
89
+ for name, pop in world.populations.items():
90
+ pop_history: list[dict] = []
91
+ for generation_index, gen in enumerate(pop.generations):
92
+ a_a, A_A, a_A, A_a = calc_nbr_type_allele(gen)
93
+ pct = to_purcent(a_a, A_A, a_A, A_a)
94
+ pop_history.append(
95
+ {
96
+ "generation": generation_index,
97
+ "a_a": a_a,
98
+ "A_A": A_A,
99
+ "a_A": a_A,
100
+ "A_a": A_a,
101
+ "pourcentages": pct,
102
+ }
103
+ )
104
+ history[name] = pop_history
105
+ return history
106
+
107
+
108
+ __all__ = ["Simulation", "build_history"]