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

import os

import sys

import getopt

import wx

from wx.lib.agw.advancedsplash import AdvancedSplash, AS_NOTIMEOUT, AS_CENTER_ON_SCREEN

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

import os

import sys

import shutil

from time import time as gettime

from threading import Lock, Timer, currentThread

import wx.lib.buttons

import wx.lib.statbmp

import wx.stc

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

import os

import sys

import getopt

import traceback

import threading

from threading import Thread, Semaphore, Lock, currentThread

from functools import partial

import runtime

def OnTaskBarChangePort(self, evt):

dlg = ParamsEntryDialog(None, _("Enter a port number "), defaultValue=str(self.pyroserver.port))

if dlg.ShowModal() == wx.ID_OK:

self.pyroserver.port = int(dlg.GetValue())

self.pyroserver.Restart()

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

import os

import re

import traceback

from copy import deepcopy

from lxml import etree

self.GetCTRoot().logger.write_warning(XSDSchemaErrorMessage.format(a1=fname, a2=lnum, a3=src))

self.CreateCodeFileBuffer(True)

except Exception as exc:

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

raise Exception

import shutil

from operator import add

from functools import reduce

from lxml import etree

LDFLAGS = []

if CTNLDFLAGS is not None:

# LDFLAGS can be either string

LDFLAGS += [CTNLDFLAGS]

# or list of strings

elif isinstance(CTNLDFLAGS, list):

self.MandatoryParams = ("BaseParams", self.BaseParams)

basexmlfile.close()

except Exception as exc:

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

self.CTNParams = (name, obj)

xmlfile.close()

except Exception as exc:

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

try:

self.CTNAddChild(pname, ptype)

except Exception as exc:

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

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

import sys

import base64

import wx

import wx.grid

import wx.aui

from editors.EditorPanel import EditorPanel

from editors.SFCViewer import SFC_Viewer

def DecodeFileSystemPath(path, is_base64=True):

if is_base64:

path = base64.decodestring(path)

def AppendMenu(parent, help, kind, text, id=wx.ID_ANY):

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

from copy import deepcopy

import os

import re

import datetime

from time import localtime

from functools import reduce

import util.paths as paths

from plcopen import *

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

import re

from functools import reduce

from plcopen import PLCOpenParser

from plcopen.structures import *

"""

import os

import traceback

import time

from functools import reduce

from distutils.dir_util import copy_tree

import wx

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

import os

import sys

import getopt

from functools import reduce

# Translation between IEC types and Can Open types

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

import sys

import traceback

from functools import partial

from threading import Thread, Event

from twisted.internet import reactor, threads

from autobahn.twisted import wamp

# create a WAMP application session factory

component_config = types.ComponentConfig(

extra={"ID": ID})

session_factory = wamp.ApplicationSessionFactory(

config=component_config)

reactor.run(installSignalHandlers=False)

def WampSessionProcMapper(funcname):

def catcher_func(*args, **kwargs):

if _WampSession is not None:

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

from functools import reduce

import wx

import wx.stc

if wx.Platform == '__WXMSW__':

faces = {

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

from time import time as gettime

from cycler import cycler

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

from matplotlib.backends.backend_agg import FigureCanvasAgg

from mpl_toolkits.mplot3d import Axes3D

from editors.DebugViewer import REFRESH_PERIOD

from controls.DebugVariablePanel.DebugVariableViewer import *

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

import socket

import wx

import wx.lib.mixins.listctrl as listmix

from zeroconf import ServiceBrowser, Zeroconf, get_all_addresses

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

import os

import wx

from util.BitmapLibrary import GetBitmap

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

from datetime import datetime

from time import time as gettime

from weakref import proxy

import numpy

import wx

from controls.CustomToolTip import CustomToolTip, TOOLTIP_WAIT_PERIOD

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

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

import re

import wx

import wx.grid

import wx.lib.buttons

from plcopen.structures import LOCATIONDATATYPES, TestIdentifier, IEC_KEYWORDS, DefaultType

from plcopen.VariableInfoCollector import _VariableInfos

if colname == "Type" and isinstance(value, tuple):

if value[0] == "array":

return "ARRAY [%s] OF %s" % (",".join(map("..".join, value[2])), value[1])

value = str(value)

if colname in ["Class", "Option"]:

return _(value)

model = re.compile(r"%[IQM][XBWLD]?(.*\.|)")

prefix = model.match(old_location).group(0)

addr = int(re.split(model, old_location)[-1]) + 1

if not row_content.Class:

row_content.Class = self.DefaultTypes.get(self.Filter, self.Filter)

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

import re

import datetime

import wx

Returns text representation for a variable value

@return: variable value as a string

"""

# -----------------------------------------------

# integer and floating point number type methods

if value is not None:

up = evt.GetEventType() == wx.EVT_SPIN_UP._getEvtType()

value = value + 1 if up else value - 1

evt.Skip()

# -----------------------------------------------

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

import re

import wx

import wx.grid

import wx.stc as stc

import wx.lib.buttons

from plcopen.plcopen import TestTextElement

if col == 0:

return row + 1

else:

def _updateColAttrs(self, grid):

"""

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

import re

import wx

import wx.grid

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

import wx

from editors.Viewer import *

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

import wx

import wx.lib.buttons

import wx.grid

from graphics.GraphicCommons import REFRESH_HIGHLIGHT_PERIOD, ERROR_HIGHLIGHT

from controls import CustomGrid, CustomTable, DurationCellEditor

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

import re

from functools import reduce

import wx

import wx.stc

from graphics.GraphicCommons import ERROR_HIGHLIGHT, SEARCH_RESULT_HIGHLIGHT, REFRESH_HIGHLIGHT_PERIOD

from plcopen.structures import ST_BLOCK_START_KEYWORDS, IEC_BLOCK_START_KEYWORDS, LOCATIONDATATYPES

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

import math

from time import time as gettime

from threading import Lock

import wx

from plcopen.structures import *

from plcopen.types_enums import ComputePouName

middle = True

new_pos = [bbx.x, bbx.y]

result = self.Controler.PasteEditedElementInstances(self.TagName, element, new_pos, middle, self.Debug)

self.RefreshBuffer()

self.RefreshView(selection=result)

self.RefreshVariablePanel()

import os

import shutil

import csv

from lxml import etree

import wx

# self.GetCTRoot().logger.write_warning(

# XSDSchemaErrorMessage % (filepath + error))

except Exception as exc:

xmlfile.close()

if self.modules_infos is not None:

parentmod = mod

builtins.__dict__['_'] = get_translation

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

import wx

from graphics.GraphicCommons import *

from plcopen.structures import *

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

from math import *

import wx

from graphics.ToolTipProducer import ToolTipProducer

y -= 5

height += 5

rect = wx.Rect(x - abs(movex), y - abs(movey), width + 2 * abs(movex), height + 2 * abs(movey))

self.ValueSize = self.ParentBlock.Parent.GetMiniTextExtent(self.ComputedValue)

if self.ValueSize is not None:

width, height = self.ValueSize

if self.Value is not None and not isinstance(self.Value, bool) and self.Value != "undefined":

dc.SetFont(self.ParentBlock.Parent.GetMiniFont())

dc.SetTextForeground(wx.NamedColour("purple"))

self.ValueSize = self.ParentBlock.Parent.GetMiniTextExtent(self.ComputedValue)

if self.ValueSize is not None:

width, height = self.ValueSize

rect = rect.Union(self.StartConnected.GetRedrawRect(movex, movey))

if self.EndConnected:

rect = rect.Union(self.EndConnected.GetRedrawRect(movex, movey))

self.ValueSize = self.Parent.GetMiniTextExtent(self.ComputedValue)

if self.ValueSize is not None:

width, height = self.ValueSize

if self.Value is not None and not isinstance(self.Value, bool) and self.Value != "undefined":

dc.SetFont(self.Parent.GetMiniFont())

dc.SetTextForeground(wx.NamedColour("purple"))

self.ValueSize = self.Parent.GetMiniTextExtent(self.ComputedValue)

if self.ValueSize is not None:

width, height = self.ValueSize

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

import wx

from graphics.GraphicCommons import *

from graphics.DebugDataConsumer import DebugDataConsumer

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

import wx

from graphics.GraphicCommons import *

from graphics.DebugDataConsumer import DebugDataConsumer

#

import os

import sys

import re

import wx

makePO(appDirPath, option['domain'], option['verbose'])

exit_code = 0

except IOError as e:

if option['mo']:

makeMO(appDirPath, option['moTarget'], option['domain'], option['verbose'], option['forceEnglish'])

exit_code = 0

# used in safety-critical situations without a full and competent review.

# dictionary implementing:

# key - string with the description we want in the request plugin GUI

# tuple - (modbus function number, request type, max count value,

# used in safety-critical situations without a full and competent review.

import os

from modbus.mb_utils import *

from ConfigTreeNode import ConfigTreeNode

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

import re

from collections import OrderedDict

from lxml import etree

from xmlclass import *

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

import os

import re

import util.paths as paths

from xmlclass import GenerateParserFromXSD

self.CreateCodeFileBuffer(False)

self.OnCTNSave()

except Exception as exc:

if error is not None:

self.GetCTRoot().logger.write_error(

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

from threading import Thread, Lock, Event, Condition

import ctypes

import os

import hashlib

from tempfile import mkstemp

from functools import wraps, partial

import _ctypes

from runtime.typemapping import TypeTranslator

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

import time

import json

import os

import re

from autobahn.twisted import wamp

from autobahn.twisted.websocket import WampWebSocketClientFactory, connectWS

from autobahn.wamp import types, auth

self.register(GetCallee(name), '.'.join((ID, name)), registerOptions)

for name in SubscribedEvents:

for func in DoOnJoin:

func(self)

def publishWithOwnID(self, eventID, value):

ID = self.config.extra["ID"]

class ReconnectingWampWebSocketClientFactory(WampWebSocketClientFactory, ReconnectingClientFactory):

def PublishEvent(eventID, value):

if getWampStatus() == "Attached":

def PublishEventWithOwnID(eventID, value):

if getWampStatus() == "Attached":

# WEB CONFIGURATION INTERFACE

def getDownloadUrl(ctx, argument):

if lastKnownConfig is not None:

child(WAMP_SECRET_URL).\

child(lastKnownConfig["ID"] + ".secret")

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

import os

import wx

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

import os

import sys

def AbsFile(file):

if isinstance(file, str):

return file

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

import os

import re

import datetime

from xml.dom import minidom

from xml.sax.saxutils import unescape

from collections import OrderedDict

from lxml import etree

if not extract:

return attr

if len(attr.childNodes) == 1:

else:

# content is a CDATA

txt = ''

for node in attr.childNodes:

if not (node.nodeName == "#text" and node.data.strip() == ''):

def GetNormalizedString(attr, extract=True):

"extract": ExtractAny,

"generate": GenerateAny,

"initial": InitialAny,

}

def FindTypeInfos(factory, infos):

namespace, name = DecomposeQualifiedName(infos)

return factory.GetQualifiedNameInfos(name, namespace)

return infos

def AddToLookupClass(self, name, parent, typeinfos):

lookup_name = self.etreeNamespaceFormat % name

self.AddEquivalentClass(name, typeinfos)

typeinfos = self.etreeNamespaceFormat % typeinfos

lookup_classes = self.ComputedClassesLookUp.get(lookup_name)

self.ComputedClassesLookUp[lookup_name] = lookup_classes

def ExtractTypeInfos(self, name, parent, typeinfos):

namespace, type_name = DecomposeQualifiedName(typeinfos)

infos = self.GetQualifiedNameInfos(type_name, namespace)

if name != "base":

if infos["type"] == COMPLEXTYPE:

type_name, parent = self.SplitQualifiedName(type_name, namespace)

result = self.CreateClass(type_name, parent, infos)

self.Namespaces[self.TargetNamespace][result["name"]] = result

return result

elif infos["type"] == ELEMENT and infos["elmt_type"]["type"] == COMPLEXTYPE:

type_name, parent = self.SplitQualifiedName(type_name, namespace)

result = self.CreateClass(type_name, parent, infos["elmt_type"])

self.Namespaces[self.TargetNamespace][result["name"]] = result

return result

else:

self.ParseSchema()

for name, infos in list(self.Namespaces[self.TargetNamespace].items()):

if infos["type"] == ELEMENT:

infos["elmt_type"]["type"] == COMPLEXTYPE:

self.ComputeAfter.append((name, None, infos["elmt_type"], True))

while len(self.ComputeAfter) > 0:

result = self.CreateClass(*self.ComputeAfter.pop(0))

self.Namespaces[self.TargetNamespace][result["name"]] = result

elif infos["type"] == COMPLEXTYPE:

self.ComputeAfter.append((name, None, infos))

while len(self.ComputeAfter) > 0:

result = self.CreateClass(*self.ComputeAfter.pop(0))

if result is not None and \

self.Namespaces[self.TargetNamespace][result["name"]] = result

elif infos["type"] == ELEMENTSGROUP:

elements = []

elif "choices" in infos:

elements = infos["choices"]

for element in elements:

element["elmt_type"]["type"] == COMPLEXTYPE:

self.ComputeAfter.append((element["name"], infos["name"], element["elmt_type"]))

while len(self.ComputeAfter) > 0:

result = self.CreateClass(*self.ComputeAfter.pop(0))

if result is not None and \

self.Namespaces[self.TargetNamespace][result["name"]] = result

for name, parents in self.ComputedClassesLookUp.items():

def GetElementClass(self, element_tag, parent_tag=None, default=DefaultElementClass):

element_class = self.LookUpClasses.get(element_tag, (default, None))

if not isinstance(element_class, dict):

return self.GetElementClass(element_class[0], default=default)

return element_class[0]

element_with_parent_class = element_class.get(parent_tag, default)

return self.GetElementClass(element_with_parent_class, default=default)

return element_with_parent_class

"%s " % etree.QName(child.tag).localname

for child in element])

for possible_class in element_class:

possible_class = self.GetElementClass(possible_class)

if possible_class.StructurePattern.match(children) is not None:

return possible_class

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

import os

import re

import datetime

from types import FunctionType

from xml.dom import minidom

from xmlclass.xmlclass import *

if typeinfos["type"] in ["restriction", "extension"]:

# Search for base type definition

basetypeinfos = factory.FindSchemaElement(typeinfos["base"], SIMPLETYPE)

if basetypeinfos is None:

raise "\"%s\" isn't defined!" % typeinfos["base"]

elif typeinfos["type"] == "list":

# Search for item type definition

itemtypeinfos = factory.FindSchemaElement(typeinfos["itemType"], SIMPLETYPE)

if itemtypeinfos is None:

raise "\"%s\" isn't defined!" % typeinfos["itemType"]

# Search for member types definition

membertypesinfos = []

for membertype in typeinfos["memberTypes"]:

infos = factory.FindSchemaElement(membertype, SIMPLETYPE)

if infos is None:

raise ValueError("\"%s\" isn't defined!" % membertype)

attrnames = {}

if base is not None:

basetypeinfos = factory.FindSchemaElement(base)

attrnames = dict([(x["name"], True) for x in basetypeinfos["attributes"]])

for element in elements:

raise ValueError("Only group composed of \"choice\" can be referenced in \"choice\" element!")

choices_tmp = []

for choice in elmtgroup["choices"]:

elmt_type = "%s_%s" % (elmtgroup["name"], choice["name"])

if factory.TargetNamespace is not None:

elmt_type = "%s:%s" % (factory.TargetNamespace, elmt_type)

raise ValueError("Only group composed of \"sequence\" can be referenced in \"sequence\" element!")

elements_tmp = []

for element in elmtgroup["elements"]:

elmt_type = "%s_%s" % (elmtgroup["name"], element["name"])

if factory.TargetNamespace is not None:

elmt_type = "%s:%s" % (factory.TargetNamespace, elmt_type)

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

"normalizedString": {

"type": SIMPLETYPE,

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"token": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"base64Binary": {

"facets": NUMBER_FACETS,

"generate": GenerateSimpleTypeXMLText(str),

"initial": lambda: "",

},

"dateTime": {

"facets": NUMBER_FACETS,

"generate": GenerateSimpleTypeXMLText(str),

"initial": lambda: "",

},

"gYearMonth": {

"facets": NUMBER_FACETS,

"generate": GenerateSimpleTypeXMLText(str),

"initial": lambda: "",

},

"gMonth": {

"facets": NUMBER_FACETS,

"generate": GenerateSimpleTypeXMLText(str),

"initial": lambda: "",

},

"gMonthDay": {

"facets": NUMBER_FACETS,

"generate": GenerateSimpleTypeXMLText(str),

"initial": lambda: "",

},

"gDay": {

"facets": NUMBER_FACETS,

"generate": GenerateSimpleTypeXMLText(str),

"initial": lambda: "",

},

"Name": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"QName": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"NCName": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"anyURI": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"language": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "en",

},

"ID": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"IDREF": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"IDREFS": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"ENTITY": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"ENTITIES": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"NOTATION": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"NMTOKEN": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

"NMTOKENS": {

"facets": STRING_FACETS,

"generate": GenerateSimpleTypeXMLText(lambda x: x),

"initial": lambda: "",

},

# Complex Types