HYTOS

    def __init__(self, graphicsView, update_line_type, update_flow_mark, update_spec):

        self._update_spec = update_spec

            connectAttrImpl(self, self._update_line_type, self._update_flow_mark, self._update_spec)

            self.obj = Worker(self.graphicsView, self.ui.checkBoxUpdateLineType.isChecked(), self.ui.checkBoxUpdateFlowMark.isChecked(), self.ui.checkBoxUpdateSpec.isChecked())

        self.checkBoxUpdateSpec = QtWidgets.QCheckBox(ConnectAttr)

        self.checkBoxUpdateSpec.setObjectName("checkBoxUpdateSpec")

        self.horizontalLayout_2.addWidget(self.checkBoxUpdateSpec)

        self.checkBoxUpdateSpec.setText(_translate("ConnectAttr", "Update Segment Break"))

def connectAttrImpl(worker, update_line_type, update_flow_mark, update_spec):

        spec_breaks = []

        flow_marks = []

                spec_breaks.append(item)

        tracer = LineNoTracer(symbols, lines, lineNos, spec_breaks, lineIndicator, vendor_packages, end_breaks)

            # check duplication

        """ update spec break """

        if update_spec:

            for spec_break in spec_breaks:

                spec_break.transfer.onRemoved.emit(spec_break)

            spec_break_names = docdata.getSymbolListByType('type', 'Segment Breaks')

            if len(spec_break_names) is not 0:

                svgFileName = spec_break_names[0].sName

                symbol = docdata.getSymbolByQuery('name', svgFileName)

                svgFilePath = os.path.join(docdata.getCurrentProject().getSvgFilePath(), symbol.getType(), svgFileName + '.svg')

                specBreakAttrsFull = [attr for attr in docdata.getSymbolAttribute('Segment Breaks') if attr.Target == 'ALL' and attr.AttributeType == 'Spec']

                specBreakAttrs = [attr.Attribute for attr in specBreakAttrsFull]

                line_ends = []

                # append upstream first and append downstream

                for lineNo in lineNos:

                    for run in lineNo.runs:

                        line_ends.append(run.items[0]) if issubclass(type(run.items[0]), SymbolSvgItem) or (type(run.items[0]) is QEngineeringLineItem and (run.items[0].lineType == 'Secondary' or run.items[0].lineType == 'Primary')) else None

                for lineNo in lineNos:

                    for run in lineNo.runs:

                        if run.items[0] is not run.items[-1]:

                            line_ends.append(run.items[-1]) if issubclass(type(run.items[-1]), SymbolSvgItem) or (type(run.items[-1]) is QEngineeringLineItem and (run.items[-1].lineType == 'Secondary' or run.items[-1].lineType == 'Primary')) else None

                spec_breaks = []

                for line_end in line_ends:

                    for connector in line_end.connectors:

                        if connector.connectedItem is not None and type(connector.connectedItem.owner) is QEngineeringLineNoTextItem and connector.connectedItem.owner is not line_end.owner:

                            spec_break = []  # upstream, downstream, [spec, up value, down value], ... , [ ... ]

                            match = False

                            for prop, value in [[prop, value] for prop, value in line_end.owner.getAttributes().items() if prop.Attribute in specBreakAttrs]:

                                for prop2, value2 in [[prop2, value2] for prop2, value2 in connector.connectedItem.owner.getAttributes().items() if prop2.Attribute in specBreakAttrs and prop2.UID == prop.UID]:

                                    if str(prop.UID) == str(prop2.UID) and value != value2:

                                        if not match:

                                            spec_break.extend([line_end, connector.connectedItem])

                                            match = True

                                        spec_break.append([prop.Attribute, value, value2])

                            if match:

                                spec_breaks.append(spec_break)

                if spec_breaks:

                    # check duplication

                    dupl = set()

                    for i in range(len(spec_breaks)):

                        for j in range(len(spec_breaks)):

                            if i == j:

                                continue

                            else:

                                setI = set([spec_breaks[i][0], spec_breaks[i][1]])

                                setJ = set([spec_breaks[j][0], spec_breaks[j][1]])

                                if not (setI - setJ):

                                    index = [i, j]

                                    index.sort()

                                    index = tuple(index)

                                    dupl.add(index)

                    dupl = list(set([(indexSet[1]) for indexSet in list(dupl)]))

                    dupl.sort(reverse=True)

                    for index in dupl:

                        spec_breaks.pop(index)

                    spec_break_items = []

                    for spec in spec_breaks:

                        for connector in spec[0].connectors:

                            if connector.connectedItem is spec[1]:

                                spec_break = SymbolSvgItem.createItem(symbol.getType(), svgFilePath)

                                pt = [connector.center()[0] - float(symbol.getOriginalPoint().split(',')[0]), connector.center()[1] - float(symbol.getOriginalPoint().split(',')[1])]

                                origin = [0, 0]

                                if 2 == len(symbol.getOriginalPoint().split(',')):

                                    tokens = symbol.getOriginalPoint().split(',')

                                    origin = [pt[0] + float(tokens[0]), pt[1] + float(tokens[1])]

                                spec_break.buildItem(svgFileName, symbol.getType(), 0.0, pt, [spec_break.boundingRect().width(), spec_break.boundingRect().height()], origin, [], symbol.getBaseSymbol(), symbol.getAdditionalSymbol(), symbol.getHasInstrumentLabel())

                                attrs = spec_break.getAttributes()

                                for key in attrs.keys():

                                    if key.Attribute == 'UpStream':

                                        attrs[key] = spec[0]

                                    elif key.Attribute == 'DownStream':

                                        attrs[key] = spec[1]

                                for attr, value, value2 in spec[2:]:

                                    for full in specBreakAttrsFull:

                                        if full.Attribute == attr:

                                            attrs[full] = [value, value2]

                                spec_break_items.append(spec_break)

                    for spec_break_item in spec_break_items:

                        spec_break_item.transfer.onRemoved.connect(App.mainWnd().itemRemoved)

                        spec_break_item.addSvgItemToScene(worker.graphicsView.scene)

      <widget class="QCheckBox" name="checkBoxUpdateSpec">

       <property name="text">

        <string>Update Segment Break</string>

       </property>

      </widget>

     </item>

     <item>