Implémentation Python

class xphs1903.outils.FilCopie(orig: Queue[__annotationlib_name_1__], dest: list[Queue[__annotationlib_name_2__]], conv: list[Callable[[__annotationlib_name_3__], __annotationlib_name_4__]])

Fil copiant les éléments d’une file vers d’autres.

Paramètres:

• orig (queue.Queue[A]) – File d’origine, à copier.

• dest (list[queue.Queue[B]]) – Files vers lesquelles copier les éléments de orig.

• conv (list[Callable[[A], B]]) – Fonctions de conversion à utiliser.

orig

File d’origine, à copier.

Type:

queue.Queue[A]

dest

Files vers lesquelles copier FilCopie.orig.

Type:

list[queue.Queue[B]]

conv

Fonctions de conversion de FilCopie.orig vers FilCopie.dest.

Type:

list[Callable[[A], B]]

start()

Démarre l’exécution du fil, et donc la copie d’une file aux autres. Héritée de threading.Thread.

Notes

Cette classe est destinée à être utilisée quand les différentes files se trouvent dans différents fils d’exécution, avec normalement aucune file traitée uniquement dans le fil principal. En particulier, cette classe résout le problème d’envoyer un message d’un fil d’exécution à plusieurs autres fils.

Par exemple, dans un programme de communication et affichage de base du cours PHS1903, on peut vouloir afficher et traiter les mêmes données de manières différentes et simultanées. On peut donc relier la file de sortie du fil de prise de données aux files d’entrée des fils de traitement et d’affichage.

Voir aussi

threading.Thread

Classe de fil d’exécution en parallèle

queue.Queue

Classe de file partagée entre fils

itertools.tee

Fonction similaire mais pour des itérateurs

Exemples

Un exemple simplifié à en être inutile et trivial serait le suivant. Rien n’est fait avec les données, mais on peut voir qu’elles ont été copiées vers les deux files de sortie.

>>> with FilCopie(
...     queue.Queue(), [queue.Queue(), queue.Queue()], lambda x: x
... ) as fil:
...     for i in range(10):
...         fil.orig.put(1)
>>>  while (res := fil.dest[0].get()):
...     print(res)
...
0
1
2
3
4
5
6
7
8
9
>>> while res := fil.dest[1].get():
...     print(res)
0
1
2
3
4
5
6
7
8
9

join() → None

Termine le fil d’exécution.

Attend que la file FilCopie.orig soit vide, puis celles listées dans FilCopie.dest. Termine ensuite le fil d’exécution.

Type renvoyé:

None

run() → None

Copie les éléments de FilCopie.orig vers FilCopie.dest.

Type renvoyé:

None

shutdown() → None

Termine le fil d’exécution.

Appelle threading.Thread.shutdown() sur FilCopie.orig et sur les files listées dans FilCopie.dest. Termine ensuite le fil d’exécution.

Type renvoyé:

None

class xphs1903.outils.ObjetImmuable(cls: type, *args: GenericArgsType, **kargs: GenericKArgsType)

Capsule pour rendre la modification d’un objet peu praticable.

C’est une classe de convenance pour plus facilement gérer des objets dont certains paramètres ne devraient pas être modifiés sans grande considération. Le cas d’utilisation précis qui a mené à la création de la classe est celui des lignes de communication série, qui une fois créées, ne devraient pas voir leurs paramètres modifiés sans un changement équivalent pour l’interlocuteur. La solution simple est d’empêcher toute modification après l’initialisation.

Paramètres:

• cls (type) – Type d’objet immuable à créer.

• *args (GenericArgsType)

• **kargs (GenericKArgsType)

_fixed

Drapeau indiquant si l’objet est mutable ou non.

Type:

bool, default=True

_object

Objet de type cls créé à l’initialisation.

Type:

Final[cls]

_lock

Cadenas pour limiter la modification à un seul fil d’exécution à la fois.

Type:

RLock

Notes

Cette classe ne devrait pas être instanciée directement. La fonction-usine xphs1903.outils.immuable() devrait être utilisée pour créer des variantes immuables de types.

Les capacités de cette classe sont limitées, et ne sont testées que dans le contexte de son utilisation pour des lignes séries. C’est un contexte particulier, où les objets serial.Serial ne sont pas conçus pour être utilisés à travers plusieurs fils. Par précaution, je rends l’objet immuable pour les fils qui en ont besoin, sans affecter son fonctionnement interne.

Avertissement

Ne pas utiliser cette classe sur des types internes de Python, ou en général s’il existe déjà une variante immuable ou hashable d’une classe.

Python offre déjà des séquences de types mutables et immuables [2] et des variantes d’objets pouvant être passées d’un fil d’exécution à un autre. D’autres modules font de même, ça vaut la peine de lire la documentation avant d’improviser avec la classe xphs1903.outils.ObjetImmuable pour encapsuler une nouvelle classe. D’ailleurs, même la documentation de PySerial offre une alternative, avec serial.threaded. Les objets pandas sont un bon exemple d’objets avec lesquels il faut aussi faire attention dans les fils d’exécution. [3] [4]

Références

[2]

https://docs.python.org/3/reference/datamodel.html#immutable-sequences

[3]

https://pandas.pydata.org/docs/user_guide/gotchas.html#gotchas-thread-safety

[4]

https://stackoverflow.com/questions/13592618/python-pandas-dataframe-thread-safe

Voir aussi

serial.threaded

module d’exécution en parallèle de PySerial.

threading

module d’exécution en parallèle de Python.

queue

module de communication entre fils de Python.

asyncio

module d’exécution asynchrone en Python.

Exemples

L’objet devrait être créé via xphs1903.outils.immuable().

>>> int_i = immuable(int)
>>> int_i(35)
35

À l’intérieur d’un bloc with l’objet devient modifiable:

>>> with int_i:
...     int_i += 1
...
>>> int_i
36

fixer() → None

Rend l’objet immuable.

Type renvoyé:

None

libérer() → None

Rend l’objet muable.

Type renvoyé:

None

xphs1903.outils.se_tourner_les_pouces(sieste: float = 0.1, fils: list[Thread] | None = None) → None

Une fonction qui ne fait rien en attendant que des fils se terminent.

L’usage de cette fonction est minimal. Si vous avez plusieurs fils d’exécution, vous pouvez utiliser le motif suivant:

fil.start()
se_tourner_les_pouces()
fil.join()

pour continuer l’exécution de fil jusqu’à ce que l’utilisateur tape Control-C ou que fil signale KeyboardInterrupt. Une autre forme d’appel est:

fil1.start()
fil2.start()
se_tourner_les_pouces(fils=(fil1, fil2))
fil1.join()
fil2.join()

pour sortir du programme quand fil1, fil2 ont terminé de s’exécuter.

Paramètres:

• sieste (float, default=0.1) – Le temps de chaque pause du programme principal.

• fils (list[threading.Thread], optional) – Une liste de fils d’exécution à surveiller.

Type renvoyé:

None

Notes

Cette fonction peut aussi être utilisée avec les objets de type xphs1903.outils.para.FilBase.

with FilBase() as fil1, FileBase(), fil2:
    se_tourner_les_pouces(fils=(fil1, fil2))