1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

# This program is free software; you can redistribute it and/or

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

# of the License, or (at your option) any later version.

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

# You should have received a copy of the GNU General Public License

    23

# along with this program; if not, write to the Free Software

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

    27

import os

    28

from POULibrary import POULibrary

    29

from py_ext.PythonFileCTNMixin import PythonFileCTNMixin

    30

import util.paths as paths

    31

    32

pyext_python_lib_code = """

    33

    34

import csv

    35

from collections import OrderedDict

    36

    37

csv_int_files = {}

    38

def CSVRdInt(fname, rowidx, colidx):

    39

    \"\"\"

    40

    Return value at row/column pointed by integer indexes

    41

    Assumes data starts at first row and first column, no headers.

    42

    \"\"\"

    43

    global csv_int_files

    44

    data = csv_int_files.get(fname, None)

    45

    if data is None:

    46

        data = list()

    47

        try:

    48

            csvfile = open(fname, 'rt', encoding='utf-8')

    49

        except IOError:

    50

            return "#FILE_NOT_FOUND"

    51

        try:

    52

            dialect = csv.Sniffer().sniff(csvfile.read(1024))

    53

            csvfile.seek(0)

    54

            reader = csv.reader(csvfile, dialect)

    55

            for row in reader:

    56

                data.append(row)

    57

        except csv.Error as e:

    58

            return "#CSV_ERROR"

    59

        finally:

    60

            csvfile.close()

    61

        csv_int_files[fname] = data

    62

    63

    try:

    64

        row = data[rowidx]

    65

    except IndexError:

    66

        return "#ROW_NOT_FOUND"

    67

    68

    try:

    69

        return row[colidx]

    70

    except IndexError:

    71

        return "#COL_NOT_FOUND"

    72

    73

    74

csv_str_files = {}

    75

def CSVRdStr(fname, rowname, colname):

    76

    \"\"\"

    77

    Return value at row/column pointed by a pair of names as string

    78

    Assumes first row is column headers and first column is row name.

    79

    \"\"\"

    80

    global csv_str_files

    81

    entry = csv_str_files.get(fname, None)

    82

    if entry is None:

    83

        data = dict()

    84

        try:

    85

            csvfile = open(fname, 'rt', encoding='utf-8')

    86

        except IOError:

    87

            return "#FILE_NOT_FOUND"

    88

        try:

    89

            dialect = csv.Sniffer().sniff(csvfile.read(1024))

    90

            csvfile.seek(0)

    91

            reader = csv.reader(csvfile, dialect)

    92

            headers = dict([(name, index) for index, name in enumerate(reader.__next__()[1:])])

    93

            for row in reader:

    94

                data[row[0]] = row[1:]

    95

        except csv.Error:

    96

            return "#CSV_ERROR"

    97

        finally:

    98

            csvfile.close()

    99

        csv_str_files[fname] = (headers, data)

   100

    else:

   101

        headers, data = entry

   102

   103

    try:

   104

        row = data[rowname]

   105

    except KeyError:

   106

        return "#ROW_NOT_FOUND"

   107

   108

    try:

   109

        colidx = headers[colname]

   110

    except KeyError:

   111

        return "#COL_NOT_FOUND"

   112

   113

    try:

   114

        return row[colidx]

   115

    except IndexError:

   116

        return "#COL_NOT_FOUND"

   117

   118

   119

csv_int_files = {}

   120

def CSVWrInt(fname, rowidx, colidx, content, save):

   121

    \"\"\"

   122

    Update value at row/column pointed by integer indexes

   123

    Assumes data starts at first row and first column, no headers.

   124

    \"\"\"

   125

    if save > 0:

   126

        global csv_int_files

   127

        data = csv_int_files.get(fname, None)

   128

        if data is None:

   129

            data = list()

   130

            try:

   131

                csvfile = open(fname, 'rt', encoding='utf-8')

   132

            except IOError:

   133

                return "#FILE_NOT_FOUND"

   134

            try:

   135

                dialect = csv.Sniffer().sniff(csvfile.read(1024))

   136

                csvfile.seek(0)

   137

                reader = csv.reader(csvfile, dialect)

   138

                for row in reader:

   139

                    data.append(row)

   140

            except csv.Error as e:

   141

                return "#CSV_ERROR"

   142

            finally:

   143

                csvfile.close()

   144

            csv_int_files[fname] = data

   145

   146

        try:

   147

            row = data[rowidx]

   148

        except IndexError:

   149

            return "#ROW_NOT_FOUND"

   150

   151

        try:

   152

            row[colidx] = content

   153

        except IndexError:

   154

            return "#COL_NOT_FOUND"

   155

   156

        wfile = open(fname, 'rt+', encoding='utf-8')

   157

        wdialect = csv.Sniffer().sniff(wfile.read(1024))

   158

        wfile.seek(0)

   159

        writer = csv.writer(wfile, wdialect)

   160

        for row in data:

   161

            writer.writerow(row)

   162

        wfile.truncate()

   163

        wfile.close()

   164

   165

    return "#SUCCESS"

   166

   167

   168

def pyext_csv_reload():

   169

    global csv_int_files, csv_str_files

   170

    csv_int_files.clear()

   171

    csv_str_files.clear()

   172

   173

"""

   174

   175

   176

class PythonLibrary(POULibrary):

   177

    def GetLibraryPath(self):

   178

        return paths.AbsNeighbourFile(__file__, "pous.xml")

   179

   180

    def Generate_C(self, buildpath, varlist, IECCFLAGS):

   181

   182

        plc_python_filepath = paths.AbsNeighbourFile(__file__, "plc_python.c")

   183

        plc_python_file = open(plc_python_filepath, 'r')

   184

        plc_python_code = plc_python_file.read()

   185

        plc_python_file.close()

   186

        python_eval_fb_list = []

   187

        for v in varlist:

   188

            if v["vartype"] == "FB" and v["type"] in ["PYTHON_EVAL",

   189

                                                      "PYTHON_POLL"]:

   190

                python_eval_fb_list.append(v)

   191

        python_eval_fb_count = max(1, len(python_eval_fb_list))

   192

   193

        # prepare python code

   194

        plc_python_code = plc_python_code % {

   195

            "python_eval_fb_count": python_eval_fb_count}

   196

   197

        Gen_Pythonfile_path = os.path.join(buildpath, "py_ext.c")

   198

        pythonfile = open(Gen_Pythonfile_path, 'w')

   199

        pythonfile.write(plc_python_code)

   200

        pythonfile.close()

   201

   202

        runtimefile_path = os.path.join(buildpath, "runtime_00_pyext.py")

   203

        runtimefile = open(runtimefile_path, 'w')

   204

        runtimefile.write(pyext_python_lib_code)

   205

        runtimefile.close()

   206

        return ((["py_ext"], [(Gen_Pythonfile_path, IECCFLAGS)], True), "",

   207

                ("runtime_00_pyext.py", open(runtimefile_path, "rb")))

   208

   209

   210

class PythonFile(PythonFileCTNMixin):

   211

   212

    def GetIconName(self):

   213

        return "Pyfile"