HYTOS

    import os, math

            freezed_spec_breaks = []

            for spec_break in spec_breaks:

                if not spec_break.prop('Freeze'):

                    spec_break.transfer.onRemoved.emit(spec_break)

                else:

                    freezed_spec_breaks.append(spec_break)

            for line in lines:

                line.clear_labels()

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

            if len(spec_break_names) is not 0:

                configs = AppDocData.instance().getConfigs('Range', 'Detection Ratio')

                ratio = float(configs[0].value) if 1 == len(configs) else 1.5

                ratio *= 2

                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' or attr.AttributeType == 'String')]

                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)

                    # up to here

                    spec_break_items = []

                    for spec in spec_breaks:

                        dupl = False

                        for freezed in freezed_spec_breaks:

                            freezed_attrs = freezed.getAttributes()

                            up = [attr.AssocItem for attr in freezed_attrs if attr.Attribute == 'UpStream']

                            down = [attr.AssocItem for attr in freezed_attrs if attr.Attribute == 'DownStream']

                            if up and down:

                                if (up[0] is spec[0] and down[0] is spec[1]) or (

                                        up[0] is spec[1] and down[0] is spec[0]):

                                    dupl = True

                                    break

                        if dupl:

                            continue

                        for connector in spec[0].connectors:

                            if connector.connectedItem is spec[1]:

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

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

                                      90 + 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] = str(spec[0])

                                        spec_break.add_assoc_item(spec[0], key.AttrAt, force=True)

                                        key.AssocItem = spec[0]

                                    elif key.Attribute == 'DownStream':

                                        attrs[key] = str(spec[1])

                                        spec_break.add_assoc_item(spec[1], key.AttrAt, force=True)

                                        key.AssocItem = spec[1]

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

                                    for full in specBreakAttrsFull:

                                        if full.Attribute == attr:

                                            attrs[full] = [value, value2]

                                # find label text for spec break line

                                stream_line = [spec[0], spec[1]]

                                stream_track = [spec[1], spec[0]]

                                stream_res = [False, False]

                                for index in range(len(stream_line)):

                                    while True:

                                        if type(stream_line[index]) is QEngineeringLineItem:

                                            stream_res[index] = True

                                            break

                                        else:

                                            find_next = False

                                            connected_count = 0

                                            for connectorr in stream_line[index].connectors:

                                                connected_count += 1

                                                if connectorr.connectedItem and stream_track[

                                                    index] is not connectorr.connectedItem and stream_line[

                                                    index].next_connected(stream_track[index],

                                                                          connectorr.connectedItem):

                                                    stream_track[index] = stream_line[index]

                                                    stream_line[index] = connectorr.connectedItem

                                                    find_next = True

                                                    break

                                            if not find_next:

                                                # prevent infinite loop

                                                if connected_count == 2:

                                                    for connectorr in stream_line[index].connectors:

                                                        if connectorr.connectedItem and not connectorr.connectedItem is \

                                                                                            stream_track[index]:

                                                            stream_line[index] = connectorr.connectedItem

                                                            stream_track[index] = stream_line[index]

                                                            find_next = True

                                                            break

                                                    if not find_next:

                                                        break

                                                else:

                                                    break

                                if stream_res[0] and stream_res[1]:

                                    texts = [item for item in worker.scene.items() if

                                             type(item) is QEngineeringTextItem and item.owner is None]

                                    positioning = False

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

                                        up_texts = [text for text in texts if text.text() == value]

                                        down_texts = [text for text in texts if text.text() == value2]

                                        up_down_texts = [up_texts, down_texts]

                                        up_down_find = [None, None]

                                        for index in range(len(up_down_texts)):

                                            minDist = sys.maxsize

                                            for up_down_text in up_down_texts[index]:

                                                dx = connector.center()[0] - up_down_text.center().x()

                                                dy = connector.center()[1] - up_down_text.center().y()

                                                dist = (

                                                                   up_down_text.sceneBoundingRect().height() + up_down_text.sceneBoundingRect().width()) * ratio / 2

                                                length = math.sqrt(dx * dx + dy * dy)

                                                if length < dist and length < minDist:

                                                    up_down_find[index] = up_down_text

                                        if up_down_find[0] and up_down_find[1]:

                                            for index in range(len(stream_line)):

                                                attrs = stream_line[index].getAttributes()

                                                for key in attrs.keys():

                                                    if key.Attribute == attr:

                                                        attrs[key] = up_down_find[index].text()

                                                        key.AssocItem = up_down_find[index]

                                                        stream_line[index].add_assoc_item(up_down_find[index],

                                                                                          key.AttrAt, force=True)

                                                        up_down_find[index].owner = stream_line[index]

                                                        break

                                            if not positioning:

                                                # set spec break position between

                                                positioning = True

                                                new_x = round(

                                                    (up_down_find[0].center().x() + up_down_find[1].center().x()) / 2)

                                                new_y = round(

                                                    (up_down_find[0].center().y() + up_down_find[1].center().y()) / 2)

                                                spec_break.loc = [new_x - spec_break.symbolOrigin[0],

                                                                  new_y - spec_break.symbolOrigin[1]]

                                                spec_break.origin = [new_x, new_y]

                                                if abs(up_down_find[0].center().x() - up_down_find[

                                                    1].center().x()) < abs(

                                                        up_down_find[0].center().y() - up_down_find[1].center().y()):

                                                    spec_break.angle = 1.57

                                                else:

                                                    spec_break.angle = 3.14

                                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.scene)

                    spec_break_items.extend(freezed_spec_breaks)