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) 2016: Andrey Skvortsov <andrej.skvortzov@gmail.com>

     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

from __future__ import absolute_import

    28

from __future__ import print_function

    29

import os

    30

import sys

    31

import tempfile

    32

import shutil

    33

import random

    34

import time

    35

from time import time as gettime

    36

from threading import Lock, Timer, currentThread

    37

    38

from six.moves import cPickle, xrange

    39

import wx.lib.buttons

    40

import wx.lib.statbmp

    41

import wx.stc

    42

    43

    44

import version

    45

from editors.EditorPanel import EditorPanel

    46

from editors.Viewer import Viewer

    47

from editors.TextViewer import TextViewer

    48

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    49

from editors.DataTypeEditor import DataTypeEditor

    50

from util import paths as paths

    51

from util.MiniTextControler import MiniTextControler

    52

from util.ProcessLogger import ProcessLogger

    53

from util.BitmapLibrary import GetBitmap

    54

from controls.LogViewer import LogViewer

    55

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    56

from controls import EnhancedStatusBar as esb

    57

from dialogs.AboutDialog import ShowAboutDialog

    58

    59

from plcopen.types_enums import \

    60

    ComputeConfigurationName, \

    61

    LOCATION_CONFNODE, \

    62

    LOCATION_MODULE, \

    63

    LOCATION_GROUP, \

    64

    LOCATION_VAR_INPUT, \

    65

    LOCATION_VAR_OUTPUT, \

    66

    LOCATION_VAR_MEMORY, \

    67

    ITEM_PROJECT, \

    68

    ITEM_RESOURCE, \

    69

    ITEM_CONFNODE

    70

    71

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL

    72

    73

from IDEFrame import \

    74

    TITLE,\

    75

    EDITORTOOLBAR,\

    76

    FILEMENU,\

    77

    EDITMENU,\

    78

    DISPLAYMENU,\

    79

    PROJECTTREE,\

    80

    POUINSTANCEVARIABLESPANEL,\

    81

    LIBRARYTREE,\

    82

    PAGETITLES,\

    83

    IDEFrame, \

    84

    EncodeFileSystemPath, \

    85

    DecodeFileSystemPath

    86

    87

    88

beremiz_dir = paths.AbsDir(__file__)

    89

    90

    91

def Bpath(*args):

    92

    return os.path.join(beremiz_dir, *args)

    93

    94

def AppendMenu(parent, help, id, kind, text):

    95

    return parent.Append(help=help, id=id, kind=kind, text=text)

    96

    97

MAX_RECENT_PROJECTS = 9

    98

    99

   100

if wx.Platform == '__WXMSW__':

   101

    faces = {

   102

        'mono': 'Courier New',

   103

        'size': 8,

   104

    }

   105

else:

   106

    faces = {

   107

        'mono': 'FreeMono',

   108

        'size': 10,

   109

    }

   110

   111

   112

MainThread = currentThread().ident

   113

REFRESH_PERIOD = 0.1

   114

   115

   116

class LogPseudoFile(object):

   117

    """ Base class for file like objects to facilitate StdOut for the Shell."""

   118

    def __init__(self, output, risecall):

   119

        self.red_white = 1

   120

        self.red_yellow = 2

   121

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   122

        self.output = output

   123

        self.risecall = risecall

   124

        # to prevent rapid fire on rising log panel

   125

        self.rising_timer = 0

   126

        self.StackLock = Lock()

   127

        self.YieldLock = Lock()

   128

        self.RefreshLock = Lock()

   129

        self.TimerAccessLock = Lock()

   130

        self.stack = []

   131

        self.LastRefreshTime = gettime()

   132

        self.LastRefreshTimer = None

   133

        self.refreshPending = False

   134

   135

    def write(self, s, style=None):

   136

        self.StackLock.acquire()

   137

        self.stack.append((s, style))

   138

        self.StackLock.release()

   139

        current_time = gettime()

   140

        with self.TimerAccessLock:

   141

            if self.LastRefreshTimer is not None:

   142

                self.LastRefreshTimer.cancel()

   143

                self.LastRefreshTimer = None

   144

        elapsed = current_time - self.LastRefreshTime

   145

        if elapsed > REFRESH_PERIOD:

   146

            self._should_write()

   147

        else:

   148

            with self.TimerAccessLock:

   149

                if self.LastRefreshTimer is None:

   150

                    self.LastRefreshTimer = Timer(REFRESH_PERIOD - elapsed, self._timer_expired)

   151

                    self.LastRefreshTimer.start()

   152

   153

    def _timer_expired(self):

   154

        self._should_write()

   155

        with self.TimerAccessLock:

   156

            self.LastRefreshTimer = None

   157

   158

    def _should_write(self):

   159

        if MainThread == currentThread().ident:

   160

            app = wx.GetApp()

   161

            if app is not None:

   162

                self._write()

   163

                if self.YieldLock.acquire(0):

   164

                    app.Yield()

   165

                    self.YieldLock.release()

   166

        else:

   167

            with self.RefreshLock:

   168

                if not self.refreshPending:

   169

                    self.refreshPending = True

   170

                    wx.CallAfter(self._write)

   171

   172

    def _write(self):

   173

        if self.output:

   174

            with self.RefreshLock:

   175

                self.output.Freeze()

   176

                self.output.AnnotationClearAll()

   177

                self.StackLock.acquire()

   178

                for s, style in self.stack:

   179

                    if style is None:

   180

                        style = self.black_white

   181

                    if style != self.black_white:

   182

                        self.output.StartStyling(self.output.GetLength(), 0xff)

   183

   184

                    # Temporary deactivate read only mode on StyledTextCtrl for

   185

                    # adding text. It seems that text modifications, even

   186

                    # programmatically, are disabled in StyledTextCtrl when read

   187

                    # only is active

   188

                    start_pos = self.output.GetLength()

   189

                    self.output.SetReadOnly(False)

   190

                    self.output.AppendText(s)

   191

                    self.output.SetReadOnly(True)

   192

                    text_len = self.output.GetLength() - start_pos

   193

   194

                    if style != self.black_white:

   195

                        self.output.SetStyling(text_len, style)

   196

                self.stack = []

   197

                self.StackLock.release()

   198

                self.output.ScrollToEnd()

   199

                self.output.Thaw()

   200

                self.LastRefreshTime = gettime()

   201

                newtime = time.time()

   202

                if newtime - self.rising_timer > 1:

   203

                    self.risecall(self.output)

   204

                self.rising_timer = newtime

   205

                self.refreshPending = False

   206

   207

   208

    def write_warning(self, s):

   209

        self.write(s, self.red_white)

   210

   211

    def write_error(self, s):

   212

        self.write(s, self.red_yellow)

   213

   214

    def flush(self):

   215

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   216

        # text. It seems that text modifications, even programmatically, are

   217

        # disabled in StyledTextCtrl when read only is active

   218

        self.output.SetReadOnly(False)

   219

        self.output.SetText("")

   220

        self.output.SetReadOnly(True)

   221

   222

    def isatty(self):

   223

        return False

   224

   225

    def progress(self, text):

   226

        l = max(self.output.GetLineCount()-2, 0)

   227

        self.output.AnnotationSetText(l, text)

   228

        self.output.AnnotationSetVisible(wx.stc.STC_ANNOTATION_BOXED)

   229

        self.output.AnnotationSetStyle(l, self.black_white)

   230

        if self.YieldLock.acquire(0):

   231

            app = wx.GetApp()

   232

            app.Yield()

   233

            self.YieldLock.release()

   234

   235

   236

ID_FILEMENURECENTPROJECTS = wx.NewId()

   237

   238

   239

class Beremiz(IDEFrame):

   240

   241

    def _init_utils(self):

   242

        self.ConfNodeMenu = wx.Menu(title='')

   243

        self.RecentProjectsMenu = wx.Menu(title='')

   244

   245

        IDEFrame._init_utils(self)

   246

   247

    def _init_coll_FileMenu_Items(self, parent):

   248

        AppendMenu(parent, help='', id=wx.ID_NEW,

   249

                   kind=wx.ITEM_NORMAL, text=_(u'New') + '\tCTRL+N')

   250

        AppendMenu(parent, help='', id=wx.ID_OPEN,

   251

                   kind=wx.ITEM_NORMAL, text=_(u'Open') + '\tCTRL+O')

   252

        parent.AppendMenu(ID_FILEMENURECENTPROJECTS, _("&Recent Projects"), self.RecentProjectsMenu)

   253

        parent.AppendSeparator()

   254

        AppendMenu(parent, help='', id=wx.ID_SAVE,

   255

                   kind=wx.ITEM_NORMAL, text=_(u'Save') + '\tCTRL+S')

   256

        AppendMenu(parent, help='', id=wx.ID_SAVEAS,

   257

                   kind=wx.ITEM_NORMAL, text=_(u'Save as') + '\tCTRL+SHIFT+S')

   258

        AppendMenu(parent, help='', id=wx.ID_CLOSE,

   259

                   kind=wx.ITEM_NORMAL, text=_(u'Close Tab') + '\tCTRL+W')

   260

        AppendMenu(parent, help='', id=wx.ID_CLOSE_ALL,

   261

                   kind=wx.ITEM_NORMAL, text=_(u'Close Project') + '\tCTRL+SHIFT+W')

   262

        parent.AppendSeparator()

   263

        AppendMenu(parent, help='', id=wx.ID_PAGE_SETUP,

   264

                   kind=wx.ITEM_NORMAL, text=_(u'Page Setup') + '\tCTRL+ALT+P')

   265

        AppendMenu(parent, help='', id=wx.ID_PREVIEW,

   266

                   kind=wx.ITEM_NORMAL, text=_(u'Preview') + '\tCTRL+SHIFT+P')

   267

        AppendMenu(parent, help='', id=wx.ID_PRINT,

   268

                   kind=wx.ITEM_NORMAL, text=_(u'Print') + '\tCTRL+P')

   269

        parent.AppendSeparator()

   270

        AppendMenu(parent, help='', id=wx.ID_EXIT,

   271

                   kind=wx.ITEM_NORMAL, text=_(u'Quit') + '\tCTRL+Q')

   272

   273

        self.Bind(wx.EVT_MENU, self.OnNewProjectMenu, id=wx.ID_NEW)

   274

        self.Bind(wx.EVT_MENU, self.OnOpenProjectMenu, id=wx.ID_OPEN)

   275

        self.Bind(wx.EVT_MENU, self.OnSaveProjectMenu, id=wx.ID_SAVE)

   276

        self.Bind(wx.EVT_MENU, self.OnSaveProjectAsMenu, id=wx.ID_SAVEAS)

   277

        self.Bind(wx.EVT_MENU, self.OnCloseTabMenu, id=wx.ID_CLOSE)

   278

        self.Bind(wx.EVT_MENU, self.OnCloseProjectMenu, id=wx.ID_CLOSE_ALL)

   279

        self.Bind(wx.EVT_MENU, self.OnPageSetupMenu, id=wx.ID_PAGE_SETUP)

   280

        self.Bind(wx.EVT_MENU, self.OnPreviewMenu, id=wx.ID_PREVIEW)

   281

        self.Bind(wx.EVT_MENU, self.OnPrintMenu, id=wx.ID_PRINT)

   282

        self.Bind(wx.EVT_MENU, self.OnQuitMenu, id=wx.ID_EXIT)

   283

   284

        self.AddToMenuToolBar([(wx.ID_NEW, "new", _(u'New'), None),

   285

                               (wx.ID_OPEN, "open", _(u'Open'), None),

   286

                               (wx.ID_SAVE, "save", _(u'Save'), None),

   287

                               (wx.ID_SAVEAS, "saveas", _(u'Save As...'), None),

   288

                               (wx.ID_PRINT, "print", _(u'Print'), None)])

   289

   290

    def _RecursiveAddMenuItems(self, menu, items):

   291

        for name, text, helpstr, children in items:

   292

            if len(children) > 0:

   293

                new_menu = wx.Menu(title='')

   294

                menu.AppendMenu(wx.ID_ANY, text, new_menu)

   295

                self._RecursiveAddMenuItems(new_menu, children)

   296

            else:

   297

                item = menu.Append(wx.ID_ANY, text, helpstr)

   298

                self.Bind(wx.EVT_MENU, self.GetAddConfNodeFunction(name), item)

   299

   300

    def _init_coll_AddMenu_Items(self, parent):

   301

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   302

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   303

   304

    def _init_coll_HelpMenu_Items(self, parent):

   305

        def handler(event):

   306

            return wx.MessageBox(

   307

                version.GetCommunityHelpMsg(),

   308

                _(u'Community support'),

   309

                wx.OK | wx.ICON_INFORMATION)

   310

   311

        item = parent.Append(wx.ID_ANY, _(u'Community support'), '')

   312

        self.Bind(wx.EVT_MENU, handler, item)

   313

   314

        parent.Append(help='', id=wx.ID_ABOUT,

   315

                      kind=wx.ITEM_NORMAL, text=_(u'About'))

   316

        self.Bind(wx.EVT_MENU, self.OnAboutMenu, id=wx.ID_ABOUT)

   317

   318

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   319

        parent.SetFieldsCount(3)

   320

   321

        parent.SetStatusText(number=0, text='')

   322

        parent.SetStatusText(number=1, text='')

   323

        parent.SetStatusText(number=2, text='')

   324

   325

        parent.SetStatusWidths([-1, 300, 200])

   326

   327

    def _init_ctrls(self, prnt):

   328

        IDEFrame._init_ctrls(self, prnt)

   329

   330

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   331

   332

        inspectorID = wx.NewId()

   333

        self.Bind(wx.EVT_MENU, self.OnOpenWidgetInspector, id=inspectorID)

   334

        accels = [wx.AcceleratorEntry(wx.ACCEL_CTRL | wx.ACCEL_ALT, ord('I'), inspectorID)]

   335

   336

        for method, shortcut in [("Stop",     wx.WXK_F4),

   337

                                 ("Run",      wx.WXK_F5),

   338

                                 ("Transfer", wx.WXK_F6),

   339

                                 ("Connect",  wx.WXK_F7),

   340

                                 ("Clean",    wx.WXK_F9),

   341

                                 ("Build",    wx.WXK_F11)]:

   342

            def OnMethodGen(obj, meth):

   343

                def OnMethod(evt):

   344

                    if obj.CTR is not None:

   345

                        obj.CTR.CallMethod('_'+meth)

   346

                    wx.CallAfter(self.RefreshStatusToolBar)

   347

                return OnMethod

   348

            newid = wx.NewId()

   349

            self.Bind(wx.EVT_MENU, OnMethodGen(self, method), id=newid)

   350

            accels += [wx.AcceleratorEntry(wx.ACCEL_NORMAL, shortcut, newid)]

   351

   352

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   353

   354

        self.LogConsole = CustomStyledTextCtrl(

   355

            name='LogConsole', parent=self.BottomNoteBook, pos=wx.Point(0, 0),

   356

            size=wx.Size(0, 0))

   357

        self.LogConsole.Bind(wx.EVT_SET_FOCUS, self.OnLogConsoleFocusChanged)

   358

        self.LogConsole.Bind(wx.EVT_KILL_FOCUS, self.OnLogConsoleFocusChanged)

   359

        self.LogConsole.Bind(wx.stc.EVT_STC_UPDATEUI, self.OnLogConsoleUpdateUI)

   360

        self.LogConsole.SetReadOnly(True)

   361

        self.LogConsole.SetWrapMode(wx.stc.STC_WRAP_CHAR)

   362

   363

        # Define Log Console styles

   364

        self.LogConsole.StyleSetSpec(wx.stc.STC_STYLE_DEFAULT, "face:%(mono)s,size:%(size)d" % faces)

   365

        self.LogConsole.StyleClearAll()

   366

        self.LogConsole.StyleSetSpec(1, "face:%(mono)s,fore:#FF0000,size:%(size)d" % faces)

   367

        self.LogConsole.StyleSetSpec(2, "face:%(mono)s,fore:#FF0000,back:#FFFF00,size:%(size)d" % faces)

   368

   369

        # Define Log Console markers

   370

        self.LogConsole.SetMarginSensitive(1, True)

   371

        self.LogConsole.SetMarginType(1, wx.stc.STC_MARGIN_SYMBOL)

   372

        self.LogConsole.MarkerDefine(0, wx.stc.STC_MARK_CIRCLE, "BLACK", "RED")

   373

   374

        self.LogConsole.SetModEventMask(wx.stc.STC_MOD_INSERTTEXT)

   375

   376

        self.LogConsole.Bind(wx.stc.EVT_STC_MARGINCLICK, self.OnLogConsoleMarginClick)

   377

        self.LogConsole.Bind(wx.stc.EVT_STC_MODIFIED, self.OnLogConsoleModified)

   378

   379

        self.MainTabs["LogConsole"] = (self.LogConsole, _("Console"))

   380

        self.BottomNoteBook.AddPage(*self.MainTabs["LogConsole"])

   381

        # self.BottomNoteBook.Split(self.BottomNoteBook.GetPageIndex(self.LogConsole), wx.RIGHT)

   382

   383

        self.LogViewer = LogViewer(self.BottomNoteBook, self)

   384

        self.MainTabs["LogViewer"] = (self.LogViewer, _("PLC Log"))

   385

        self.BottomNoteBook.AddPage(*self.MainTabs["LogViewer"])

   386

        # self.BottomNoteBook.Split(self.BottomNoteBook.GetPageIndex(self.LogViewer), wx.RIGHT)

   387

   388

        StatusToolBar = wx.ToolBar(self, -1, wx.DefaultPosition, wx.DefaultSize,

   389

                                   wx.TB_FLAT | wx.TB_NODIVIDER | wx.NO_BORDER)

   390

        StatusToolBar.SetToolBitmapSize(wx.Size(25, 25))

   391

        StatusToolBar.Realize()

   392

        self.Panes["StatusToolBar"] = StatusToolBar

   393

        self.AUIManager.AddPane(StatusToolBar, wx.aui.AuiPaneInfo().

   394

                                Name("StatusToolBar").Caption(_("Status ToolBar")).

   395

                                ToolbarPane().Top().Position(1).

   396

                                LeftDockable(False).RightDockable(False))

   397

   398

        self.AUIManager.Update()

   399

   400

        self.ConnectionStatusBar = esb.EnhancedStatusBar(self, style=wx.ST_SIZEGRIP)

   401

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   402

        self.ProgressStatusBar = wx.Gauge(self.ConnectionStatusBar, -1, range=100)

   403

        self.ConnectionStatusBar.AddWidget(self.ProgressStatusBar, esb.ESB_EXACT_FIT, esb.ESB_EXACT_FIT, 2)

   404

        self.ProgressStatusBar.Hide()

   405

        self.SetStatusBar(self.ConnectionStatusBar)

   406

   407

    def __init_execute_path(self):

   408

        if os.name == 'nt':

   409

            # on windows, desktop shortcut launches Beremiz.py

   410

            # with working dir set to mingw/bin.

   411

            # then we prefix CWD to PATH in order to ensure that

   412

            # commands invoked by build process by default are

   413

            # found here.

   414

            os.environ["PATH"] = os.getcwd()+';'+os.environ["PATH"]

   415

   416

    def __init__(self, parent, projectOpen=None, buildpath=None, ctr=None, debug=True):

   417

        # Add beremiz's icon in top left corner of the frame

   418

        self.icon = wx.Icon(Bpath("images", "brz.ico"), wx.BITMAP_TYPE_ICO)

   419

        self.__init_execute_path()

   420

   421

        IDEFrame.__init__(self, parent, debug)

   422

        self.Log = LogPseudoFile(self.LogConsole, self.SelectTab)

   423

   424

        self.local_runtime = None

   425

        self.runtime_port = None

   426

        self.local_runtime_tmpdir = None

   427

   428

        self.LastPanelSelected = None

   429

   430

        # Define Tree item icon list

   431

        self.LocationImageList = wx.ImageList(16, 16)

   432

        self.LocationImageDict = {}

   433

   434

        # Icons for location items

   435

        for imgname, itemtype in [

   436

                ("CONFIGURATION", LOCATION_CONFNODE),

   437

                ("RESOURCE",      LOCATION_MODULE),

   438

                ("PROGRAM",       LOCATION_GROUP),

   439

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   440

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   441

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   442

            self.LocationImageDict[itemtype] = self.LocationImageList.Add(GetBitmap(imgname))

   443

   444

        # Icons for other items

   445

        for imgname, itemtype in [

   446

                ("Extension", ITEM_CONFNODE)]:

   447

            self.TreeImageDict[itemtype] = self.TreeImageList.Add(GetBitmap(imgname))

   448

   449

        if projectOpen is not None:

   450

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   451

   452

        if projectOpen is not None and os.path.isdir(projectOpen):

   453

            self.CTR = ProjectController(self, self.Log)

   454

            self.Controler = self.CTR

   455

            result, _err = self.CTR.LoadProject(projectOpen, buildpath)

   456

            if not result:

   457

                self.LibraryPanel.SetController(self.Controler)

   458

                self.ProjectTree.Enable(True)

   459

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   460

                self.RefreshConfigRecentProjects(os.path.abspath(projectOpen))

   461

                self.RefreshAfterLoad()

   462

            else:

   463

                self.ResetView()

   464

                self.ShowErrorMessage(result)

   465

        else:

   466

            self.CTR = ctr

   467

            self.Controler = ctr

   468

            if ctr is not None:

   469

                ctr.SetAppFrame(self, self.Log)

   470

                self.LibraryPanel.SetController(self.Controler)

   471

                self.ProjectTree.Enable(True)

   472

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   473

                self.RefreshAfterLoad()

   474

        if self.EnableDebug:

   475

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   476

   477

        self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)

   478

   479

        self._Refresh(TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU)

   480

        self.RefreshAll()

   481

        self.LogConsole.SetFocus()

   482

   483

    def RefreshTitle(self):

   484

        name = _("Beremiz")

   485

        if self.CTR is not None:

   486

            projectname = self.CTR.GetProjectName()

   487

            if self.CTR.ProjectTestModified():

   488

                projectname = "~%s~" % projectname

   489

            self.SetTitle("%s - %s" % (name, projectname))

   490

        else:

   491

            self.SetTitle(name)

   492

   493

    def StartLocalRuntime(self, taskbaricon=True):

   494

        if (self.local_runtime is None) or (self.local_runtime.exitcode is not None):

   495

            # create temporary directory for runtime working directory

   496

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   497

            # choose an arbitrary random port for runtime

   498

            self.runtime_port = int(random.random() * 1000) + 61131

   499

            self.Log.write(_("Starting local runtime...\n"))

   500

            # launch local runtime

   501

            self.local_runtime = ProcessLogger(

   502

                self.Log,

   503

                "\"%s\" \"%s\" -p %s -i localhost %s %s" % (

   504

                    sys.executable,

   505

                    Bpath("Beremiz_service.py"),

   506