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

        if not row and rowidx == len(data)-1:

    66

            raise IndexError

    67

    except IndexError:

    68

        return "#ROW_NOT_FOUND"

    69

    70

    try:

    71

        return row[colidx]

    72

    except IndexError:

    73

        return "#COL_NOT_FOUND"

    74

    75

    76

csv_str_files = {}

    77

def CSVRdStr(fname, rowname, colname):

    78

    \"\"\"

    79

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

    80

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

    81

    \"\"\"

    82

    global csv_str_files

    83

    entry = csv_str_files.get(fname, None)

    84

    if entry is None:

    85

        data = dict()

    86

        try:

    87

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

    88

        except IOError:

    89

            return "#FILE_NOT_FOUND"

    90

        try:

    91

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

    92

            csvfile.seek(0)

    93

            reader = csv.reader(csvfile, dialect)

    94

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

    95

            for row in reader:

    96

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

    97

        except csv.Error:

    98

            return "#CSV_ERROR"

    99

        finally:

   100

            csvfile.close()

   101

        csv_str_files[fname] = (headers, data)

   102

    else:

   103

        headers, data = entry

   104

   105

    try:

   106

        row = data[rowname]

   107

    except KeyError:

   108

        return "#ROW_NOT_FOUND"

   109

   110

    try:

   111

        colidx = headers[colname]

   112

    except KeyError:

   113

        return "#COL_NOT_FOUND"

   114

   115

    try:

   116

        return row[colidx]

   117

    except IndexError:

   118

        return "#COL_NOT_FOUND"

   119

   120

   121

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

   122

    \"\"\"

   123

    Update value at row/column pointed by integer indexes

   124

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

   125

    \"\"\"

   126

   127

    global csv_int_files

   128

    dialect = None

   129

    data = csv_int_files.get(fname, None)

   130

    if data is None:

   131

        data = list()

   132

        try:

   133

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

   134

        except IOError:

   135

            return "#FILE_NOT_FOUND"

   136

        try:

   137

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

   138

            csvfile.seek(0)

   139

            reader = csv.reader(csvfile, dialect)

   140

            for row in reader:

   141

                data.append(row)

   142

        except csv.Error as e:

   143

            return "#CSV_ERROR"

   144

        finally:

   145

            csvfile.close()

   146

        csv_int_files[fname] = data

   147

   148

    try:

   149

        if rowidx == len(data):

   150

            row = []

   151

            data.append(row)

   152

        else:

   153

            row = data[rowidx]

   154

    except IndexError:

   155

        return "#ROW_NOT_FOUND"

   156

   157

    try:

   158

        if rowidx > 0 and colidx >= len(data[0]):

   159

            raise IndexError

   160

        if colidx >= len(row):

   161

            row.extend([""] * (colidx - len(row)) + [content])

   162

        else:

   163

            row[colidx] = content

   164

    except IndexError:

   165

        return "#COL_NOT_FOUND"

   166

   167

    try:

   168

        wfile = open(fname, 'wt')

   169

        writer = csv.writer(wfile) if not(dialect) else csv.writer(wfile, dialect)

   170

        for row in data:

   171

            writer.writerow(row)

   172

    finally:

   173

        wfile.close()

   174

   175

    return "OK"

   176

   177

   178

def pyext_csv_reload():

   179

    global csv_int_files, csv_str_files

   180

    csv_int_files.clear()

   181

    csv_str_files.clear()

   182

   183

"""

   184

   185

   186

class PythonLibrary(POULibrary):

   187

    def GetLibraryPath(self):

   188

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

   189

   190

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

   191

   192

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

   193

        plc_python_file = open(plc_python_filepath, 'r')

   194

        plc_python_code = plc_python_file.read()

   195

        plc_python_file.close()

   196

        python_eval_fb_list = []

   197

        for v in varlist:

   198

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

   199

                                                      "PYTHON_POLL"]:

   200

                python_eval_fb_list.append(v)

   201

        python_eval_fb_count = max(1, len(python_eval_fb_list))

   202

   203

        # prepare python code

   204

        plc_python_code = plc_python_code % {

   205

            "python_eval_fb_count": python_eval_fb_count}

   206

   207

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

   208

        pythonfile = open(Gen_Pythonfile_path, 'w')

   209

        pythonfile.write(plc_python_code)

   210

        pythonfile.close()

   211

   212

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

   213

        runtimefile = open(runtimefile_path, 'w')

   214

        runtimefile.write(pyext_python_lib_code)

   215

        runtimefile.close()

   216

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

   217

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

   218

   219

   220

class PythonFile(PythonFileCTNMixin):

   221

   222

    def GetIconName(self):

   223

        return "Pyfile"