Script python : mise à jour de token et fichier log

Pour revenir à l'API, l'outil révoque mon token toutes les 30 minutes (par défaut et par sécurité). En fait, je peux même augmenter ce temps de révocation mais je trouve que c'est plutôt bien de laisser ceci comme ça.

Ah ok ! En fait, cette considération dépend de la longueur de tes tokens :

• Si on parle de tokens à la Twitter ou Github, ce sont des tokens tellement longs (plusieurs dizaines de caractères alphanumériques) que ça n'a pas vraiment d'utilité de les rafraîchir régulièrement (voire, de les rafraîchir tout court). Ce genre de token est bien adapté pour une application, car on n'a pas à les saisir manuellement. On les configure une fois pour toutes le token dans l'application qui souhaite accéder à l'API. Si ton API te propose ce genre de mécanisme, c'est à mon avis le plus propre (moins de code) tout en restant sûr.
• Si on parle de tokens à la Microsoft Authenticator, ce sont des token beaucoup plus petits et sur un alphabet bien plus restreint (typiquement, 6 chiffres). Ils sont volontairement très court, car prévus pour être saisis manuellement par l'utilisateur. Mais du coup, ils sont aussi bien plus facile à bruteforcer, et c'est pourquoi il vaut mieux les rafraîchir régulièrement. Dans ce cas de figure, ta question à tout son sens.

Bonne chance

Traceback (most recent call last):
  File "script.py", line 107, in <module>
    main()
  File "script.py", line 45, in main
    except asyncio.exceptions.CancelledError:
AttributeError: module 'asyncio' has no attribute 'exceptions'

• Je n'ai pas cette erreur de mon côté. C'est sans doute lié à ta version de python (personnellement je suis en 3.10 pour le moment). Mais effectivement, quelle que soit ta version de python, tu as entièrement raison, il vaudrait mieux utiliser asyncio.CancelError (qui semble tout le temps marcher) au lieu de  asyncio.exceptions.CancelError. Merci pour cette correction ;-)

Concernant le reste de ton message #9, ta compréhension du script est correcte.

• Faute de critère d'arrêt (par exemple un nombre de rafraîchissement) on répète indéfiniment la fonction periodic. et donc le loop.run_until_complete ne se termine jamais à moins de l'interrompre avec un signal (par exemple suite à un ctrl+C).
• Afin de fermer proprement la boucle d'événements (et en particulier les tâches asynchrones en court), on rattrape le signal et quand il a lieu, on met fin à la coroutine periodic qui est en cours.

À moins que tu aies d'autres questions, peux-tu basculer ce sujet en résolu ?

Bonne chance

En effet, il suffit de mettre à jour une variable (permanente), globale ou pas, suivant la façon dont le script est écrit.

Concernant le message #14 : pour les prochaines fois, vu qu'il s'agit d'un autre problème, même s'il te paraît mineur, ouvre une nouvelle discussion pour garder le fil de discussion propre et spécifique à un seul problème.

Réponse rapide :

Si on parle d'une méthode, tu peux aussi mémoriser l'information en question dans l'instance de l'objet que tu manipules.

WHO = "world"

class MyObjectGlob:
    def __init__(self):
        # ...
    def my_method(self, x, y, z):
        print("Hello " + WHO)
        return x + y + z

class MyObject:
    def __init__(self, who):
        self.who = who
    def my_method(self, x, y, z):
        print("Hello " + self.who)
        return x + y + z

Si on parle d'une fonction :

• Soit tu peux ajouter cette information en tant que paramètre, c'est la solution la solution que propose yg_be (voir message #15). Cela suppose cependant de pouvoir se le permettre (car à moins d'assigner une valeur par défaut à ce nouveau paramètre, il faudra corriger en conséquence tous les appels faits à cette fonction).

  WHO = "world"
  
  def f_glob(x, y, z):
      print("Hello " + WHO)
      return x + y +z
  
  def f(x, y, z, who):
      print("Hello " + who)
      return x + y +z

• Soit tu ne veux/peux pas modifier le paramètre de la fonction, typiquement parce que cette fonction est passée en callback d'une autre fonction pour tu ne peux pas changer le prototype. Dans ce cas, pour s'en sortir, tu peux créer un foncteur. Un foncteur est une instance d'objet qui se comporte comme une fonction : l'instance est dite callable (au même titre qu'une fonction ordinaire). On mémorise l'information à la construction du foncteur. Lorsqu'on appelle le foncteur (c'est-à-dire qu'on l'utilise comme si c'était une fonction ordinaire), c'est sa méthode __call__ qui est appelée.

  class Fonctor:
      def __init__(self, who):
          self.who = who
      def __call__(self, x, y ,z):
          print("Hello " + self.who)
          return x + y + z
  
  f = Fonctor("world")
  print(f(1, 2, 3))

Bonne chance

Quand tu auras décidé cela, tu pourras commencer à réfléchir à comment préserver "token" d'une exécution à l'autre.

Ok, je pense que faire la boucle à l'intérieur du programme est mieux non ? Plutôt que d'exécuter le script par crontab à chaque fois.

C'est certainement plus simple, le token sera automatiquement préservé, sans rien faire de particulier.