NOTATIONS
NOTATIONS
  **module** lang=py
    # départ
      # coding: utf-8
        *exec
          cible_python = 3
          # pour le toggle
            version_nb = 2
        notation
          x_show ::=
            print (u"++++++++++++++++ {a0}")
              {L}
          some_error ::=
            # some error : {a0}
            pass
            {L}
      # importation de notations
        INIT_PYTHON 3
        importation des manipulations de fichiers
          *import notation for files
        notation pour mise en page du code python généré
          SEP_GRAND ::=
            ##################################################
              {L}
      # modules
        import os
          import os.path
      #MODULES_PROPRES
        # système
          import os
            import os.path
            import shutil
          import sys
            # un peu de trace
              print ('version python =', sys.version_info)
              # rajout manuel
                IF_PYTHON3
                  notation
                    IMPORT_LG ::=
                      r = '{a1}'
                        if r not in sys.path and os.path.exists (r)
                          sys.path.append (r)
                      {L}
                  IMPORT_LG C:\\ANACONDA\\Library
                  IMPORT_LG C:\\ANACONDA\\sip
                  IMPORT_LG C:\\ANACONDA\\Lib\\site-packages\\matplotlib
                  IMPORT_LG D:\\KM2V2
                  notation
                    del IMPORT_LG
          import time
            from datetime import datetime
          import json
          import subprocess
          # format
            import string
              vformat = string.Formatter().vformat
        # graphiques
          import tkinter as tk
            from tkinter import *
            import tkinter.filedialog
            import tkinter.simpledialog
            import tkinter.messagebox
            import tkinter.colorchooser
            from tkinter.scrolledtext import *
          # graphiques
            # rajout manuel
              IF_PYTHON3
              import matplotlib.pyplot as plt
                from matplotlib.backends.backend_tkagg import (FigureCanvasTkAgg, NavigationToolbar2Tk)
                from matplotlib.backend_bases import key_press_handler
                from matplotlib.figure import Figure
        # base de données
          import json
        # divers
          import webbrowser
          # maths, etc
            import math
            import pandas as pd
            import numpy
          # pour cartographie
            import folium
              doc FOLIUM
                https://pypi.org/project/folium/
                  https://python-visualization.github.io/folium/
          # pour parler
            import pyttsx3
      # fonctions simples
        def dict_from_file (file)
          DESCRIPTION
            lit un fichier json
            ENTREES
              file :
                nom d'un fichier .json
            SORTIES
              d :
                dictionnaire ou liste
            ATTENTION
              il faut vérifier de lire .json, .JSON, .Json
          # tests unitaire
            manuel
          echo 'dict_from_file', file
          if file existe
            try
              with open (file, 'r', encoding = 'utf-8') as fs
                d = json.load (fs)
                  echo 'lecture ok'
                    d
              except
                some_error 'erreur de lecture de ', file
                {}
            else
              some_error 'fichier n existe pas', file
              pre = file [:-4]
                for suf in ['json', 'JSON', 'Json']
                  nfile = pre + suf
                    if nfile existe
                      try
                        echo nfile
                        with open (nfile, 'r', encoding ='utf-8') as fs
                          d = json.load (fs)
                            d
                        except
                          continue
              {}
        def file_to_dict (fname)
          dict_from_file (fname)
        def dict_to_file (d, file)
          DESCRIPTION
            écrit un dictionnaire dans un fichier au format json
              et pretty
            ENTREES
              file : nom d'un fichier .json
              d :
                dictionnaire ou liste
            SORTIES
          # tests unitaire
            manuel
          echo file
          if isinstance (d, str) and isinstance (file, dict)
            d, file = file, d
          try
            with open (file, 'w') as fs
              json.dump(d, fs, indent = 4)
                d
            except
              some_error 'fichier n existe pas', file
              False
        def file_dict_update (file, nom, val)
          DESCRIPTION
            file contient un dictionnaire
            met à jour le chap nom avec la valeur val
          try
            dico = dict_from_file (file)
            dico [nom] = val
            dict_to_file (dico, file)
            True
            except
              False
        def file_dict_value (file, nom)
          DESCRIPTION
            file contient un dictionnaire
            récupère la valeur du champ associé
          try
            dico = dict_from_file (file)
            val = dico.get (nom, False)
            val
            except
              False
        def dict_file_value (file, nom)
          DESCRIPTION
            file contient un dictionnaire
            récupère la valeur du champ associé
          file_dict_value (file, nom)
        def file_dict_delete (file, nom)
          DESCRIPTION
            file contient un dictionnaire
            suppprime le champ nom
          try
            dico = dict_from_file (file)
            if nom in dico
              del dico [nom]
            dict_to_file (dico, file)
            True
            except
              False
        # accès
          accès aux données
            def current_user ()
              # aller chercher dans la session le user_name
                try
                  S = '$session'
                    if S.startswith ('"') and S.endswith ('"')
                      S = S[1:-1]
                  except
                    False
                user_name = dict_file_value (S, 'user_name')
              user_name
            def current_org ()
              # aller chercher dans la session le org
                try
                  S = '$session'
                    if S.startswith ('"') and S.endswith ('"')
                      S = S[1:-1]
                  except
                    False
                org = dict_file_value (S, 'org')
              org
            def current_rights ()
              try
                S = '$session'
                  if S.startswith ('"') and S.endswith ('"')
                    S = S[1:-1]
                except
                  False
              rights = dict_file_value (S, 'rights')
              rights
            def current_campain ()
              # aller chercher dans la campain
                try
                  S = '$campagne'
                    if S.startswith ('"') and S.endswith ('"')
                      S = S[1:-1]
                  except
                    False
                campain = dict_file_value (S, 'campain')
              campain
          prédicats
            def has_rights (droit_min)
              # vérifie si les droits sont au moins de droit_min
                try
                  S = '$session'
                    if S.startswith ('"') and S.endswith ('"')
                      S = S[1:-1]
                  except
                    False
                rights = dict_file_value (S, 'rights')
              #
                if rights
                  CASE
                    droit_min = 'admin'
                      rights == 'admin'
                    droit_min = 'expert'
                      rights in ['admin', 'expert']
                    else
                      True
                False
            def is_org (org)
              vérifie si org est une org
                try
                  S = '$session'
                    if S.startswith ('"') and S.endswith ('"')
                      S = S[1:-1]
                  except
                    False
                org_u = dict_file_value (S, 'org')
              #
                org == org_u
          misc
        P_8 : remplacement caractères spéciaux
          global liste_chars_escape
            liste_chars_escape = [ ('é', '&eacute;'), ('è', '&egrave;'), ('à','&agrave;'), ('ù','&ugrave;'), ('ê','&ecirc;'), ('â', '&acirc;'), ('û','&ucirc;'), ('î','&icirc;'), ('ô','&ocirc;'), ('ë', '&euml;'), ('ï', '&iuml;'), ('ö','&ouml;'), ('ü','&uuml;'), ('ç','&ccedil;') ]
            liste_chars_escape = [ (u'é', '&eacute;'), (u'è', '&egrave;'), (u'à','&agrave;'), (u'ù','&ugrave;'), (u'ê','&ecirc;'), (u'â', '&acirc;'), (u'û','&ucirc;'), (u'î','&icirc;'), (u'ô','&ocirc;'), (u'ë', '&euml;'), (u'ï', '&iuml;'), (u'ö','&ouml;'), (u'ü','&uuml;'), (u'ç','&ccedil;') ]
          def P_8 (u)
            # DESCRIPTION
              pour passer d'une chaine str en une chaine escaped
            global liste_chars_escape
            if isinstance (u, str) or isinstance (u,unicode)
              for a, b in liste_chars_escape
                if a in u
                  u = u.replace (a, b)
            u
          def P_8_rev (u)
            # DESCRIPTION
              permet de passer d'une chaine escaped en unicode
            global liste_chars_escape
            if isinstance (u, str) or isinstance (u,unicode)
              if '&' in u
                for a, b in liste_chars_escape
                  if b in u
                    u = u.replace (b, a)
            u
      # pour trace
        def safe_print (*L)
          try
            print (*L)
            except
              print ('******** some error in safe_print')
      notation fenetrage nom de l'appli
        $NOM_APPLI ::= PROCESSOR
      notation de trace simple
        WARN ::=
          warn ({a1_} )
            {L}
      notation
        DEF_DB ::=
          *setf {a1}
            {L}
        FOR_ALL ::=
          *vars
            {FOR_ALL_T}
              FOR_ALL_T = L[0]
                try
                  print (len (L), type (L), type (L[0]), type (L[1]), FOR_ALL_T)
                  except
                    print ('could not print for_all_t')
            {FOR_ALL_F}
              FOR_ALL_F = L[1:]
                try
                  print (type (FOR_ALL_F))
                    print ( isinstance (FOR_ALL_F, ARBRE))
                  print (FOR_ALL_F.titre)
                  except
                    print ('could not print for_all_f')
            EXTRACT TABLE {a1_}
              by_item
              TABLE
                {FOR_ALL_T}
              FORMAT
                {FOR_ALL_F}
                {L}
          EXTRACT TABLE {a1_}
            by_item
            TABLE
              {FOR_ALL_T}
            FORMAT
              {FOR_ALL_F}
  ici