HYTOS

    from PyQt4.QtCore import *

    from PyQt4.QtGui import *

import symbol

from NominalPipeSize import NominalPipeSize

    Error = 2

    DATABASE = 'ITI_PID.db'

    def __init__(self):

        if not hasattr(self, '_equipment_attributes'):

            self._equipment_attributes = []

                try:

                    # Get a cursor object

                    cursor = conn.cursor()

                    cursor.execute(sql)

                    rows = cursor.fetchall()

                    for row in rows:

                        attr = SymbolAttr()

                        self._equipment_attributes.append(attr)

                    res = self._equipment_attributes

                # Catch the exception

                except Exception as ex:

                                                               sys.exc_info()[-1].tb_lineno))

        else:

            res = self._equipment_attributes

        result = []

            try:

                # Get a cursor object

                cursor = conn.cursor()

                cursor.execute(sql)

                comps = [(row[0], row[1], row[2], row[3]) for row in cursor.fetchall()]

                for comp in comps:

                    cursor.execute(sql)

                    attrs = cursor.fetchall()

                    data = []

from enum import Enum

from AppDocData import AppDocData

from AppDocData import Config

class DisplayOptions(Enum):

    """ This is display options class """

    DisplayByLineNo = 1

    DisplayByLineType = 2

    """

    This is display colors class

    """

        app_doc_data = AppDocData.instance()

        configs = app_doc_data.getAppConfigs('app', 'display_option')

        if configs:

    def save_data(self):

        """ save display option to database """

            configs.append(Config('app', 'display_option', str(self._option)))

            AppDocData.instance().saveAppConfigs(configs)

        except Exception as ex:

            from AppDocData import MessageType

                                    if matches:

                                        row[col].value = matches[0][1]

                options = QFileDialog.Options()

                options |= QFileDialog.DontUseNativeDialog

                file_name = QFileDialog.getSaveFileName(self, f"{_type} xlsx file", app_doc_data.project.path,

                save_file_name = None

                if file_name[0]:

                    file_name, ext = os.path.splitext(file_name[0])

import os

import sys

import sqlite3

'''

    @brief      HMB data

            row += 1

    def set_equipment_data(self):

        try:

            equipTable = self.ui.tableWidgetEquipmentDataList

            app_doc_data = AppDocData.instance()

import MainWindow_UI

import QtImageViewer

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\Shapes')

from EngineeringAbstractItem import QEngineeringAbstractItem

import uuid

    """ This is MainWindow class """

    addMessage = pyqtSignal(Enum, str)

# coding: utf-8

""" This is NominalPipeSize module """

    """ This is nominal pipe size table class """

    def __init__(self):

import sys

import os.path

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

        from PyQt4.QtGui import *

    except ImportError:

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

__author__ = "humkyung <humkyung.doftech.co.kr>"

__version__ = '1.0.0'

    """ This is image viewer scene class """

    contents_changed = pyqtSignal()

    def removeItem(self, item):

        """ remove given item from scene """

        QGraphicsScene.removeItem(self, item)

# coding: utf-8

    __instance = None

    @classmethod

        if not cls.__instance:

            cls.__instance = cls(*args, **kargs)

            cls.instance = cls.__getInstance

# coding: utf-8

""" This is TextItemFactor module """

import re

try:

    from PyQt5.QtCore import *

    from PyQt5.QtGui import *

        raise ImportError("ImageViewerQt: Requires PyQt5 or PyQt4.")

from AppDocData import *

import sys, os

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\Shapes')

from EngineeringTextItem import QEngineeringTextItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from EngineeringReservedWordTextItem import QEngineeringReservedWordTextItem

from SpecialItemTypesDialog import SpecialItemTypes

    """ This is TextItemFactor class """

    def __init__(self):

        self.delimiter = '"'

        self.lineNoDelimiter = '!-!'

                    kyouho 2018.07.04 edit for isLineNo method (add parameter)

                    humkyung 2018.08.08 fill linePropertyData and tagSeqNoPattern if given data is None

                    euisung 2018.11.19  now textitemfactory set plain text in createTextItem() for allowables

    def createTextItem(self, textInfo):

        from Configs import LineNoConfig

                if visibleOption == 'Random':

                    rgb = docData.colors

                    item.change_color(QColor(rgb.red, rgb.green, rgb.blue).name())

                else:

                    configs = docData.getConfigs('Line No', 'Configuration')

                    configs = configs[0].value.split(self.delimiter)

                    if index >= 0:

                        value = values[index]

                        line_properties = docData.getLinePropertiesByUID(color_property)

                            if sizeUnit == "Inch":

                                value = docData.convertInchToMetric(value)

                    item.special_item_type = SpecialItemTypes.instance().find_match_exactly(item)

                docData.texts.append(item)

        except Exception as ex:

            from AppDocData import MessageType

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        return item

    '''

        @brief      Check Text startwith word

        @author     kyouho

        @date       2018.07.04

    '''

    def isStartWithWord(self, text, word):

        sliceText = text[0:len(word[0])]

        if sliceText == word[0]:

        else:

            return (False,)

    '''

        @brief      Check Text startwith number

        @author     kyouho

        @date       2018.07.05

    '''

    def isStartWithNumber(self, text):

        sliceText = text[0:1]

        num = ''

        if self.isNumber(sliceText):

            text = text[1:len(text)]

            while len(text) > 0:

                sliceText = text[0:1]

                if self.isNumber(sliceText):

                    text = text[1:len(text)]

                    num += text

                else:

                    break

            return (True, text, num)

        else:

            return (False,)

        @date       2018.07.05

        @history    kyouho 2018.07.09   add Refular Expression

    '''

    def isNumber(self, num):

        p = re.compile('(^[0-9]+$)')

        result = p.match(num)

        @author     kyouho

        @date       2018.07.05

    '''

    def isTagSeqNo(self, text, pattern):

        try:

            if pattern is not None:

            else:

                return (False,)

        except Exception as ex:

    '''

        @brief      Check Number

        @author     kyouho

        @date       2018.07.05

    '''

    def isLimitWord(self, text, pattern):

        try:

            if pattern is not None:

                if length:  # Length가 있으면 Length만큼 문자열을 가져와 길이를 검사한다.

                    result = eval('attr[:' + str(length) + ']')

                    if int(length) != len(result):

                elif isNumber:

                    match = re.search(re.compile('^[0-9]+'), attr)

                    if match:

                    else:

                        return (False,)

                else:

            else:

                return (False,)

        except Exception as ex:

    '''

        @brief      Check if given text is Note No Text (ex : NOTE 1, NOTE 2, ...)

        @date       2018.04.26

        @history    2018.05.16  Jeongwoo    Modify Validator flag

    '''

    def create_note_no_text(self, textInfo):

        item = None

                if 1 == len(configs) and configs[0].value:

                    symbol_names = configs[0].value.split(',')

                    for symbol in appDocData.symbols:

                            item = QEngineeringNoteItem(symbol=symbol)

                            item.owner = symbol

                            symbol.add_assoc_item(item, 0)

        @author humkyung

        @date   2018.05.02

    '''

    def isSizeText(self, text, delimiter='X'):

        from NominalPipeSize import NominalPipeSizeTable

        # for imperial

        if text.find('"') is not -1:

            first = text[:text.find('"') + 1]

        # for metric

        else:

            split_text = text.strip().split(delimiter.upper())

        tokens = [first, second] if second is not None and len(second) is not 0 else [first]

        index = 0

        for token in tokens:

            if matches:

                tokens[index] = matches[0]

            else:

                return False

            index += 1

        return delimiter.join(tokens)

    '''

        @brief  check if given text is tag no

        @author humkyung

        @date   2018.05.03

    '''

    def isTagNoText(self, text):

        from CodeTables import CodeTable