Skip to content
Snippets Groups Projects
Select Git revision
  • main default protected
1 result
Blame Permalink
physicalParameter.py 3.70 KiB
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 






import csv
import shelve
import sys
import logging
import argparse


class Roscop:

    '''
    This class read a csv file describing physical parameter with ROSCOP codification
    '''

    # constructor with values by default
    def __init__(self, file):
        # attibutes
        # public:
        self.file = file
        # private:
        self.__hash = {}
        # constructor build objet by reading the file
        self.read()

    # overloading operators
    def __str__(self):
        ''' overload string representation '''
        return 'Class Roscop, file: %s, size = %d' % (self.file, len(self))

    def __getitem__(self, key):
        ''' overload r[key] 
            for a given key return the values as a dictionary '''
        if key not in self.__hash:
            logging.error(
                " Invalid key: \"{}\"".format(key))
        else:
            return self.__hash[key]

    def __setitem__(self, key, value):
        ''' overload r[key] = value '''
        if type(value) is not dict:
            logging.error(
                " The value: \"{}\" must be a dictionary".format(value))
            return

        if key not in self.__hash:
            self.__hash[key] = value
        else:
            logging.error(
                " Modify the existing key: \"{}\" is not allowed".format(key))

    def __repr__(self):
        ''' overload print() '''
        return super().__repr__()

    def __len__(self):
        ''' overload len() '''
        return len(self.__hash)

    # methods public
    def displayCode(self, key):
        ''' for a given key print it's name and values as a dictionary '''
        print("%s :" % key)
        print(self[key])

    # read code roscop file
    def read(self):
        with open(self.file, 'rt') as f:
            reader = csv.DictReader(f, delimiter=';')

            for row in reader:
                theKey = row[reader.fieldnames[0]]
                for k in reader.fieldnames:
                    # if the value of key is empty
                    if row[k] == '' or k == 'key':
                        # remove the key
                        row.pop(k)
                    else:
                        logging.debug(
                            " {} -> {}: {}".format(theKey, k, row[k]))
                self.__hash[theKey] = row

        return


# for testing in standalone context
# ---------------------------------
if __name__ == "__main__":

    # usage:
    # > python physicalParameter.py code_roscop.csv -k TEMP
    parser = argparse.ArgumentParser(
        description='This class Roscop parse a csv file describing physical parameter codification')
    parser.add_argument("-d", "--debug", help="display debug informations",
                        action="store_true")
    parser.add_argument("-k", "--key", nargs='+',
                        help="display dictionary for key(s), example -k TEMP [PSAL ...]")
    parser.add_argument("file", type=str, help="the csv file to parse")

    # display extra logging info
    # see: https://stackoverflow.com/questions/14097061/easier-way-to-enable-verbose-logging
    # https://docs.python.org/2/howto/argparse.html
    args = parser.parse_args()
    if args.debug:
        logging.basicConfig(
            format='%(levelname)s:%(message)s', level=logging.DEBUG)

    # Read the csv file and create an instance of Roscop class
    r = Roscop(args.file)
    # r = Roscop("code_roscop.csv")

    # r.read()
    print(r)

    # get -k arg(s) list
    key = args.key
    # if args list is empty, key contain NoneType
    if key is not None:
        for k in key:
            r.displayCode(k)

    print("{}: {}".format(key[0], r.returnCode(key[0])['long_name']))
    r['TOTO'] = {'uncle': 'tata'}
    print(r['TOTO'])
    r['TEMP'] = 'tata'