IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Présentation et demande faisabilité de revue de code


Sujet :

Python

  1. #1
    Membre habitué
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Mars 2015
    Messages
    138
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Morbihan (Bretagne)

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : Service public

    Informations forums :
    Inscription : Mars 2015
    Messages : 138
    Points : 138
    Points
    138
    Par défaut Présentation et demande faisabilité de revue de code
    Bonjour,

    je développe en Perl5 dans le service de prod d'un établissement public et suis les forums dédiés de developpez.net.

    De nouveaux équipements (baies de disques) à venir mettront à notre disposition une API d'admin via un module Python.
    On nous a donc demandé de commencer à nous intéresser au langage Python.
    C'est chose faite, beaucoup de lectures, et les choses commencent à prendre forme doucement.

    Les scripts que nous développons sur des serveurs RHEL suivent un modèle spécifique pour pouvoir être mis en production.
    J'ai écrit un premier squelette en Python3 et un module contenant quelques fonctions maison.
    Il fonctionne bien, mais je souhaite avoir un oeil externe pour commentaires, critiques, conseils...
    Est-ce dans les usages du forum de demander une revue de code ?

    Merci

  2. #2
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 283
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 283
    Points : 36 770
    Points
    36 770
    Par défaut
    Salut,

    Citation Envoyé par ptonnerre Voir le message
    Est-ce dans les usages du forum de demander une revue de code ?
    Postez toujours, vous verrez bien.
    En fait, çà se fait, plutôt pour des codes de débutants et n'oubliez pas que ceux que cela pourra inspirer regarderont votre code sans forcément y intégrer vos contraintes d'administration système (qui sont assez spécifiques).

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  3. #3
    Expert éminent
    Avatar de fred1599
    Homme Profil pro
    Lead Dev Python
    Inscrit en
    Juillet 2006
    Messages
    3 823
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Lead Dev Python
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Juillet 2006
    Messages : 3 823
    Points : 7 119
    Points
    7 119
    Par défaut
    +1 avec mon VDD,

    Effectivement le code peut être analysé, mais ne pas oublier d'y annoncer ce que fait la fonction par rapport au contexte.
    On pourrait, si vous avez déjà testé, demander si certaines contraintes gênantes sont apparues lors de tests.

    Plus vous donnez de détails, plus on pourra vous dire "c'est pas bien, mieux vaut par rapport à ton problème faire cela". Dire c'est pas bien, c'est facile, le plus dur est de pouvoir le justifier.
    Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
    La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

  4. #4
    Membre habitué
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Mars 2015
    Messages
    138
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Morbihan (Bretagne)

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : Service public

    Informations forums :
    Inscription : Mars 2015
    Messages : 138
    Points : 138
    Points
    138
    Par défaut
    Bonjour,

    merci pour la proposition de revue de code.

    Le script principal initialise l'environnement d'exécution via deux dictionnaires, h0 et h1.
    Les sorties standard et erreur sont redirigées vers le fichier de log, alimenté par diverses fonctions (oxa_*)
    Après quelques contrôles, la boucle de traitement principale est exécutée.

    Le module maison embarque les fonctions d'écriture dans le fichier de log et quelques utilitaires.
    La fonction oxa_debut reçoit la référence aux dictionnaires h0 et h1 et recevra une coderef via une fermeture dans la fonction set_env.
    Cette fermeture permettra aux autres fonctions d'aller chercher elles-mêmes les références aux dictionnaires h0 et h1.

    Notre besoin de revue concerne surtout les instructions Python utilisées, la structure du code étant en partie imposée.

    Script principal :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    #!/usr/bin/env python3
    # -*- coding:Utf-8 -*-
     
    from Enim_utils_v0 import source_file, script_utils, log_utils, host_utils, usage_util, balises_util, nb_lines_util, next_step_util, sep_log_util, \
                              oxa_debut, oxa_app, oxa_msg_info, oxa_msg_warn, oxa_fin
     
     
     
     
    def init_env():
        pid = os.getpid()
     
        envbatch = os.environ['PROD_TECH_ENV'] + 'envbatch'
        env      = source_file ( envbatch, True, False )
     
        script_infos          = script_utils ( __file__ )
        ( log_basename, log ) = log_utils ( script_infos.get('name'), pid )
        ( host_fqdn, host)    = host_utils()
     
        usage_msg = 'KO - Usage : ' + script_infos.get('fullname' ) + " <balise de début ou ''> <balise de fin ou ''> <arg1> <arg2> [arg3 (optionnel)]"
     
        h0 = {}
        # ne pas modifier
        h0['dft_reprise']     = 'debut'
        h0['dft_fin']         = 'fin'
        h0['na']              = 'N/A'
        h0['dash80']          = '-' * 80
        h0['dash132']         = '-' * 132
        h0['host_fqdn']       = host_fqdn
        h0['host']            = host
        h0['pid']             = pid
        h0['script_abspath']  = script_infos.get('abspath')
        h0['script_fullname'] = script_infos.get('fullname')
        h0['script_dir']      = script_infos.get('dir')
        h0['script_name']     = script_infos.get('name')
        h0['script_ext']      = script_infos.get('ext')
        h0['script_user']     = script_infos.get('user')
        h0['project']         = os.environ['PROJECT']
        h0['prod_tech_env']   = os.environ['PROD_TECH_ENV']
        h0['dir_log_oxalys']  = os.environ['REP_LOG_OXALYS']
        h0['log_basename']    = log_basename
        h0['log']             = log
        h0['dft_nb_args']     = 2           # nb arguments obligatoires (balises début et fin)
        h0['usage_msg']       = usage_msg
        # champs personnalisables
        h0['nb_args']         = 2           # nb arguments supplémentaires
        h0['nb_args_opt']     = 1           # nb arguments optionnels
        h0['domaine']         = 'PROD'
        h0['application']     = 'TECH'
        h0['balises_ok']      = ( 'debut', 'fin' )
     
        h1 = {}
        h1['nb_errors']       = 0
        h1['nb_warnings']     = 0
     
        return h0, h1
     
     
    def function1( parm1 ):
        ( h0, h1 ) = get_env()
        warnings, errors = 0, 0
     
        oxa_msg_info ( "INFO - message informatif depuis function1 : parm1" )
     
        h1['nb_warnings'] += warnings
        h1['nb_errors']   += errors
     
        return warnings, errors
     
     
    def function2( parm2 ):
        ( h0, h1 ) = get_env()
        warnings, errors = 0, 0
     
        oxa_msg_info ( "INFO - message informatif depuis function2 : parm2" )
     
        h1['nb_warnings'] += warnings
        h1['nb_errors']   += errors
     
        return warnings, errors
     
     
    def main():
        ( h0, h1 ) = init_env()
     
        # redirection STDOUT & STDERR et ouverture fichier log
        h0['default_stdout'] = sys.stdout
        h0['default_stderr'] = sys.stderr
     
        fhw = open ( h0.get('log') , 'w')
        sys.stdout = sys.stderr = fhw
        h0['log_handler']       = fhw
     
     
        # initialisation Oxa
        global get_env
        ( args, get_env ) = oxa_debut ( h0, h1 )
        oxa_msg_info ( 'Squelette Python' )
        oxa_msg_info ( 'Fichier de log ... ' + h0.get('log') )
        oxa_app ()
     
     
        # ctrl arguments
        nb_args_rcv = len ( sys.argv ) -1 # arguments reçus (-1 pour ne pas tenir compte du script)
        nb_args     = h0.get('dft_nb_args') + h0.get('nb_args')
        nb_args_max = h0.get('dft_nb_args') + h0.get('nb_args') + h0.get('nb_args_opt')
     
        if nb_args_rcv < nb_args or nb_args_rcv > nb_args_max:
            usage_util ()
     
     
        # init et controle balises début & fin
        reprise, fin = args[0], args[1]
        balises_util ( reprise, fin )
     
     
        # var3 est un argument optionnel
        var1, var2, var3 = h0.get('na'), h0.get('na'), h0.get('na')
     
        if args[2] and args[2].strip(): var1 = args[2]
        if args[3] and args[3].strip(): var2 = args[3]
     
        if len ( args ) == nb_args_max:
            if args[4] and args[4].strip(): var3 = args[4]
     
     
        # Boucle de traitement principale si pas d'erreur
        if h1.get('nb_errors') == 0:
     
            while reprise != 'fin':
     
                if reprise == 'debut':
                    sep_log_util ( reprise )
                    reprise = next_step_util ( 'step1', reprise, fin )
     
                elif reprise == 'step1':
                    sep_log_util ( reprise )
                    function1( var1 )
                    reprise = next_step_util ( 'step2', reprise, fin )
     
                elif reprise == 'step2':
                    sep_log_util ( reprise )
                    function2( var2 )
                    reprise = next_step_util ( 'fin', reprise, fin )
                else:
                    oxa_msg_err ( "KO - Etiquette reprise invalide ", 99 )
     
        # Sortie
        if h1.get('nb_errors'):
            oxa_msg_info ( h0.get('dash132') )
            suffix = 's' if h1.get('nb_errors') > 1 else ''
            oxa_msg_err ( 'ERROR - traitement terminé en erreur : ' + h1.get('nb_errors') + ' erreur' + suffix + ' rencontrée' + suffix + ' ', h1.get('nb_errors') );
        else:
            oxa_msg_info ( h0.get('dash132') )
            oxa_msg_info ( 'Fin du traitement' )
            oxa_msg_info ( '                 FIN ' + h0.get('script_name') )
            oxa_fin  ( 0 )
            sys.exit ( 0 )
     
     
    if __name__ == '__main__':
        main ()

    Module maison :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    # -*- coding: utf-8 -*
     
    from os import environ
    from subprocess import Popen, PIPE
    from datetime import datetime
    import os, getpass, re, socket, sys
     
     
    def set_env ( h0, h1 ):
        def f():
            return ( h0, h1 )
        return f
     
     
    def source_file ( script, update=True, clean=True):
        """
        Source variables from a shell script
        import them in the environment (if update==True)
        and report only the script variables (if clean==True)
        """
     
        global environ
     
        if clean:
            environ_back = dict(environ)
            environ.clear()
     
        pipe = Popen(". %s; env" % script, stdout=PIPE, shell=True)
        data = pipe.communicate()[0]
     
        env = dict((line.split("=", 1) for line in data.decode("utf-8").splitlines()))
     
        if clean:
            # remove unwanted minimal vars
            env.pop('LINES', None)
            env.pop('COLUMNS', None)
            environ = dict(environ_back)
     
        if update:
            environ.update(env)
     
        return env
     
     
    def script_utils ( script ):
        ( name, ext ) = os.path.splitext(os.path.basename(script))
     
        script_infos = {}
        script_infos['abspath']  = os.path.abspath(script)
        script_infos['fullname'] = os.path.basename(script)
        script_infos['dir']      = os.path.dirname(os.path.abspath(script))
        script_infos['name']     = name
        script_infos['ext']      = ext
        script_infos['user']     = getpass.getuser()
     
        return script_infos
     
     
    def log_utils ( script, pid ):
     
        log_dir = os.environ['REPLOG']
        regexp = r"(tech)$"
     
        if re.match ( regexp, log_dir ) is not None:
            log_dir += '/tech'
     
        now          = datetime.now()
        log_basename = script + '_' + str(pid) + '_' + now.strftime("%Y%m%d_%H%M%S") + '.log'
        log          = log_dir + '/' + log_basename
     
        fhw = open( log , 'w')
        fhw.close()
     
        return log_basename, log
     
     
    def host_utils ():
        return socket.getfqdn(), socket.gethostname()
     
     
    def usage_util ():
        ( h0, h1 ) = get_env()
        oxa_msg_err ( h0.get('usage_msg'), 99 )
     
     
    def nb_lines_util ( file ):
        nb_lines = 0
        with open( file, 'r' ) as f:
            for line in f:
                nb_lines += 1
     
        return nb_lines
     
     
    def balises_util ( balise_debut, balise_fin ):
        ( h0, h1 ) = get_env()
     
        flag = 0
        for balise in ( balise_debut, balise_fin ):
            if not balise in h0.get('balises_ok'):
                oxa_msg_warn ( 'Balise ' + '"' + balise + '"' + ' incorrecte' )
                flag += 1
     
        if flag:
            msg = 'Balises autorisées : ' + '[' + ','.join(h0.get('balises_ok')) + ']'
            oxa_msg_err( msg , flag )
     
     
    def next_step_util ( step, reprise, fin ):
        if reprise == fin:
            reprise = 'fin'
        else:
            reprise = step
        return reprise
     
     
    def sep_log_util ( label ):
        ( h0, h1 ) = get_env()
        oxa_msg_info ( h0.get('dash132') )
        oxa_msg_info ( "LABEL : " + label )
     
     
    def timestamp ():
        now          = datetime.now()
        return now.strftime("%d/%m/%Y %H:%M:%S")
     
     
    def oxa_debut ( h0, h1 ):
     
        global get_env
        get_env = set_env ( h0, h1 )
     
        print ( 'OXDAD: ' + timestamp() )
        print ( 'OXJOB: ' + h0.get('script_fullname') )
        print ( 'OXPWD: ' + h0.get('script_dir') )
        print ( 'OXUSR: ' + h0.get('script_user') )
        print ( 'OXSER: ' + h0.get('host') )
     
        args = []
        # arguments par défaut
        args.append ( h0.get('dft_reprise') )
        args.append ( h0.get('dft_fin') )
     
        cpt = -1
     
        for arg in sys.argv:
            cpt += 1
            if cpt == 1 or cpt == 2:
                if arg and arg.strip():
                    args[cpt -1] = arg
     
            if cpt > 2:
                args.append ( arg )
     
        print ( 'VALUES: [' + ' '.join(args) + ']' )
     
        return args, get_env
     
     
    def oxa_msg_info ( msg, flag = False ):
        tms = timestamp() + ' - ' if flag else ''
        print ( 'OXRES: ' + tms + msg )
     
     
    def oxa_msg_warn ( msg, flag = False ):
        tms = timestamp() + ' - ' if flag else ''
        print ( 'OXINC: ' + tms + msg )
     
     
    def oxa_app ():
        ( h0, h1 ) = get_env()
        print ( 'OXAPP: ' + h0.get('domaine') )
        print ( 'OXINC: ' + h0.get('application') )
     
     
    def oxa_msg_err ( msg, rc, flag = False ):
     
        tms = timestamp() + ' - ' if flag else ''
        print ( 'OXERR:' + tms + ' ' + msg )
     
        if rc:
            oxa_fin ( rc )
     
     
    def oxa_fin ( rc ):
        ( h0, h1 ) = get_env()
     
        if rc:
           print ( "OXERR: Erreur durant l'exécution de " + '"' + h0.get('script_fullname') + '"' + ' : RC= ' + str(rc) )
        print ( 'OXDAF: ' + timestamp() )
        print ( 'OXSTA: ' + str(rc) )
     
        # restauration stdout & stderr
        sys.stdout = h0.get( 'default_stdout' )
        sys.stderr = h0.get( 'default_stderr' )
     
        # fermeture & nombre de lignes du fichier log
        h0.get('log_handler').close()
        nb_lines = nb_lines_util( h0.get('log') )
        size     = os.path.getsize ( h0.get('log') )
     
        # si size > 10Mo , serveur de logs ne contiendra que les 400 lignes de début et les 200 de fin
        flag_truncate, head_up, head_down, tail_up, tail_down = 0, 1, 400, 0, 0
     
        if size >= 10485760:
            flag_truncate = 1
            tail_up       = nb_lines - 200 + 1
            tail_down     = nb_lines
     
        # Affichage écran de la log pour VTOM et sortie vers le répertoire scruté par
        #   Oxa en tenant compte du flag truncate
        log_oxa = h0.get('dir_log_oxalys') + '/' + h0.get('log_basename')
        fhw = open( log_oxa, 'w', encoding='iso-8859-15')
     
        with open( h0.get('log'), 'r', encoding='utf-8') as fhr:
            for i, line in enumerate( fhr ):
                flag_write = 0
     
                if flag_truncate:
                    ind = i + 1
                    if ( ind >= head_up and ind <= head_down ) or ( ind >= tail_up and ind <= tail_down ):
                        flag_write = 1
                else:
                    flag_write = 1
     
                if flag_write:
                    print ( line.rstrip() )
                    fhw.write ( line )
     
        fhw.close()
     
        sys.exit( rc )
    Exemple fichier de log produit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    pto@uvmlsrv01 /log/tech $ cat sample_12154_20190215_144730.log
    OXDAD: 15/02/2019 14:47:30
    OXJOB: sample.py
    OXPWD: /home/pto/my_devs/Python
    OXUSR: pto
    OXSER: uvmlsrv01
    VALUES: [debut fin p1 p2 p3]
    OXRES: Squelette Python
    OXRES: Fichier de log ... /log/tech/sample_12154_20190215_144730.log
    OXAPP: PROD
    OXINC: TECH
    OXRES: ------------------------------------------------------------------------------------------------------------------------------------
    OXRES: LABEL : debut
    OXRES: ------------------------------------------------------------------------------------------------------------------------------------
    OXRES: LABEL : step1
    OXRES: INFO - message informatif depuis function1 : parm1
    OXRES: ------------------------------------------------------------------------------------------------------------------------------------
    OXRES: LABEL : step2
    OXRES: INFO - message informatif depuis function2 : parm2
    OXRES: ------------------------------------------------------------------------------------------------------------------------------------
    OXRES: Fin du traitement
    OXRES:                  FIN sample
    OXDAF: 15/02/2019 14:47:30
    OXSTA: 0

    Nous aurons aussi beaucoup d'appels externes à effectuer et avons écrit un bout de code autour de subprocess.
    Même revue pour ce script. Nous pensons utiliser Popen.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*
     
    import subprocess, sys, os
    from subprocess import Popen, PIPE
     
    print ( '*** main pid ***', os.getpid() )
     
    try:
        dir = sys.argv[1]
    except:
        print ( "Erreur")
        sys.exit ( 99 )
     
    dash132 = '-' * 132
     
    lst = ['ls', '-l', dir]
    cmd = ' '.join ( lst )
    print ( '*** lst ***', lst )
    print ( '*** cmd ***', cmd )
     
    # method 1
    print ( dash132 )
    print ( '*** subprocess.call way ***')
    rc = subprocess.call ( ['ls', '-l', dir] )
    print ( rc )
     
     
    # method 2
    print ( dash132 )
    print ( '*** Popen way ***', dir)
     
    pipe = Popen( lst, bufsize=1, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False, universal_newlines=True ) # test 1 avec liste OK
    #pipe = Popen( cmd, bufsize=1, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False, universal_newlines=True ) # test 2 avec string OK
    print ( '*** called pid ***', pipe.pid )
     
    out, err = pipe.communicate()
    if out is not None and len ( out ):
        print ( out.rstrip() )
    if err is not None and len ( err) :
        print ( err.rstrip() )
    print ( pipe.returncode )
    Merci à celles et ceux qui sont arrivés jusqu'ici et pour vos retours, commentaires, critiques, améliorations...

  5. #5
    Expert éminent
    Avatar de fred1599
    Homme Profil pro
    Lead Dev Python
    Inscrit en
    Juillet 2006
    Messages
    3 823
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Lead Dev Python
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Juillet 2006
    Messages : 3 823
    Points : 7 119
    Points
    7 119
    Par défaut
    Vous n'expliquez pas ce que sont censé faire les fonctions,

    Pour moi set_env (ligne 9 à 12 du module maison) n'a aucune raison de ne pas être écrite de cette manière,

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    def set_env(h0, h1):
        return h0, h1
    évitant l'appel de fonction ligne 171 et 186. Ça aurait été utile si vous aviez dans votre code l'utilité d'un callback, mais ce n'est pas le cas.

    Pour le reste on attent quand même des détails sur les besoins de chaque fonction. Pas de soucis particuliers concernant votre code (syntaxe, conception, autres) ?
    Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
    La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

  6. #6
    Membre habitué
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Mars 2015
    Messages
    138
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Morbihan (Bretagne)

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : Service public

    Informations forums :
    Inscription : Mars 2015
    Messages : 138
    Points : 138
    Points
    138
    Par défaut
    Merci pour ces 1er éléments de réponse.

    Citation Envoyé par fred1599 Voir le message
    Pour moi set_env (ligne 9 à 12 du module maison) n'a aucune raison de ne pas être écrite de cette manière,
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    def set_env(h0, h1):
        return h0, h1
    évitant l'appel de fonction ligne 171 et 186. Ça aurait été utile si vous aviez dans votre code l'utilité d'un callback, mais ce n'est pas le cas.

    Le but de la fermeture est de ne pas passer h0 et h1 dans tous les appels de fonctions.

    La fonction oxa_debut reçoit les références aux deux dictionnaires h0, et h1 :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    def oxa_debut ( h0, h1 ):
         global get_env
         get_env = set_env ( h0, h1 )

    La fonction renvoyée par set_env, get_env, est globale et renvoie une fonction (coderef) qui se referme sur h0 et h1 (même contexte lexical) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    def set_env ( h0, h1 ):
        def f():
            return ( h0, h1 )
        return f

    Cette coderef retournée est ensuite utilisable ainsi :
    Nous ne voyons pas comment faire autrement.

  7. #7
    Expert éminent
    Avatar de fred1599
    Homme Profil pro
    Lead Dev Python
    Inscrit en
    Juillet 2006
    Messages
    3 823
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Lead Dev Python
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Juillet 2006
    Messages : 3 823
    Points : 7 119
    Points
    7 119
    Par défaut
    Je pense qu'il y a un problème de conception, où vous montrez pas tout... set_env en ce qui me concerne peut être renommer get_env avec des économies de lignes de code.

    Pour moi, selon le nommage de la fonction set_env, c'est censé modifier une variable d'environnement, hors votre fonction ne fait pas cela, elle renvoie une fonction. get_env quand à elle, récupère une variable d'environnement, ce qu'elle fait grâce à set_env (pas logique).

    Si on modifie une variable d'environnement, j'écrirai une fonction comme ci-dessous,

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    def set_env(env, variable, value):
        if variable in env:
            env[variable] = value
    Je modifie une variable se trouvant dans mon environnement par value. Je vérifie que cette variable se trouve bien dans mon environnement.

    Vous utilisez le mot clé global, moi je pense que vous n'en avez pas besoin, c'est encore un signe d'une conception bancale.

    Bref, je ne comprend pas le nommage de votre fonction, son intérêt et votre manière de penser, et cela confirme ce que j'écris déjà au-dessus
    Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
    La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

  8. #8
    Membre confirmé

    Homme Profil pro
    Bidouilleur
    Inscrit en
    Avril 2016
    Messages
    721
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Bidouilleur

    Informations forums :
    Inscription : Avril 2016
    Messages : 721
    Points : 503
    Points
    503
    Billets dans le blog
    1
    Par défaut
    Salut.

    Tu réinventes la roue en créant ton système de log, python fournit la bibliothèque logging qui est quand même assez puissante, et de ce qu'il en résulte de ton exemple de log en sortie, logging permet de faire ça assez facilement et peut basculer simplement vers une sortie fichier ou console, et ça t'éviteras de modifier les fonctions de sorties standards de sys.
    Le temps ronge l'amour comme l'acide.

  9. #9
    Expert confirmé Avatar de papajoker
    Homme Profil pro
    Développeur Web
    Inscrit en
    Septembre 2013
    Messages
    2 101
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nièvre (Bourgogne)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Septembre 2013
    Messages : 2 101
    Points : 4 446
    Points
    4 446
    Par défaut
    bonjour,

    pas encore du code python très pur (restes de perl ?)
    par exemple :
    L139 du module: cpt = -1 for arg in sys.argv: cpt += 1
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    for cpt,arg in enumerate([h0.get('dft_reprise'), h0.get('dft_fin')] + sys.argv):
    ou déclarations h1 = {} h1['nb_errors'] = 0 h1['nb_warnings'] = 0 qui peuvent être simplifiées
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    h1 = {
       'nb_errors' : 0,
       'nb_warnings' : 0
    }
    def nb_lines_util ( file ) , f est un iterateur il suffit de le consommer : return sum(1 for item in f)
    ---

    Pas d'objet ? que du procédural et aucune exception

    Formatage de code pas à la norme ... les éditeurs python ont un linteur PEP8 intégré. je suppose que vous désirez garder le même style que votre perl ?
    $moi= ( !== ) ? : ;

  10. #10
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 283
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 283
    Points : 36 770
    Points
    36 770
    Par défaut
    Salut,

    Vous avez pleins de soucis.

    Déjà tout ce qui tourne autour de get_env, set_env, h0, h1... est une jonglerie pour accéder aux mêmes dictionnaires depuis les 2 scripts.
    Avec Python, vous pourriez créer un module globs.py contenant juste:
    et juste ajouter from globs import h0, h1 dans les autres scripts pour définir dans chacun les deux variables globales (h0 et h1). Et çà fonctionne parce que les dictionnaires sont des objets mutables (i.e. hX['toto'] = 'www' modifiera le même objet, h0 = 'toto' non).

    Deuxième soucis:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    from Enim_utils_v0 import source_file, script_utils, log_utils, host_utils, usage_util, balises_util, nb_lines_util, next_step_util, sep_log_util, \
                              oxa_debut, oxa_app, oxa_msg_info, oxa_msg_warn, oxa_fin
    script_utils, log_utils, host_utils, usage_util, balises_util, nb_lines_util et oxa_debut, oxa_app, oxa_msg_info, oxa_msg_warn... sont des noms segmentés qui commencent par oxa ou se terminent par util.

    Vous pourriez créer un module utils.py contenant les fonctions script, log, host, usage, balises, nb_lines,..., écrire import utils en en-tête et accéder aux fonctions via utils.script, utils.log, ...

    Dit autrement, Python vous offre une segmentation naturelle de votre espace de noms: profitez en plutôt que d'inventer un nommage à vous.

    L'autre avantage est que vous pourriez aussi écrire import utils_v0 as utils, ce qui vous permet de tester un utils_v1 sans changer le reste du programme tout en ayant la facilité de repérage des fonctions qui dépendent d'utils et des autres.

    3ème soucis: vous ne pouvez pas programmer avec des fonctions d'un côté et des tas de variables "globales" hors contrôle de l'autre: apprenez à faire de vraies fonctions!
    Plutôt qu'écrire:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    def sep_log_util ( label ):
        ( h0, h1 ) = get_env()
        oxa_msg_info ( h0.get('dash132') )
        oxa_msg_info ( "LABEL : " + label )
    ajoutez un paramètre à la fonction:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    def sep_log_util ( label, dash132):
        oxa_msg_info ( dash132 )
        oxa_msg_info ( "LABEL : " + label )
    et comme c'est une constante, ajoutez une valeur par défaut:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    def sep_log_util ( label, dash132=DASH132):
        oxa_msg_info ( dash132 )
        oxa_msg_info ( "LABEL : " + label )
    Le principe que vous devez appliquez quand vous codez est de construire des fonctions qui sont facilement testables/lisibles (ici, c'est simple mais bon).
    Chaque fois que vous devez définir une variable externe pour que la fonction "tourne", ce sera moins facile à tester/comprendre et les modifications risquent de devenir de vrais cauchemars car tout dépend de tout.

    C'est sûr que çà complique le boulot de l'appelant car il devra ajouter ce paramètre à la fonction (s'il a besoin d'autre chose que le défaut). S'il a besoin d'avoir accès à tout h0, çà ne pose aucun soucis (modulo qu'il en ait vraiment besoin).

    4ème soucis: le découpage de votre code.
    Relisez main, il fait des tas de choses mais son boulot principal est d'appeler séquentiellement deux fonctions fonction1 et fonction2 avec les paramètres respectifs var1 et var2.

    On peut supposer que fonction1, fonction2, var1, var2 sont "variables" et donc il manque un étage i.e. au début on récupère les "variables" puis on va avoir une fonction exécuter(fonction1, var1, fonction2, var2) (par exemple) qui va les exécuter en séquence.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  11. #11
    Membre habitué
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Mars 2015
    Messages
    138
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Morbihan (Bretagne)

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : Service public

    Informations forums :
    Inscription : Mars 2015
    Messages : 138
    Points : 138
    Points
    138
    Par défaut
    Bonjour,

    merci pour vos retours qui nous serons précieux.
    Nous avons du pain sur la planche

Discussions similaires

  1. demande d'explication sur un code
    Par Zilfi63 dans le forum VBA Access
    Réponses: 4
    Dernier message: 08/06/2009, 17h05
  2. Outils de revue de code
    Par YAMKI dans le forum Qualimétrie
    Réponses: 2
    Dernier message: 15/02/2006, 12h29
  3. [Conseil] revue de code
    Par allstar dans le forum Langage
    Réponses: 2
    Dernier message: 09/11/2005, 11h02
  4. [Revue de code] Quels outils pour de grosses applis?
    Par franckR dans le forum Choisir un environnement de développement
    Réponses: 1
    Dernier message: 21/03/2004, 10h03

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo