HYTOS

    def get_hmb_data(file_path: str):

    def get_stream_from_to(self, hmb_uid: str = None, drawing_uid: str = None) -> list:

                if hmb_uid:

                    sql = f"select h.Drawing_UID, h.From_Component_UID, h.To_Component_UID, d.Name from HMB_From_To h " \

                          f"inner join Drawings d on d.UID=h.Drawing_UID " \

                          f"where Stream_No_UID = ?"

                    params = (hmb_uid,)

                else:

                    sql = f"select h.From_Component_UID, h.To_Component_UID, s.Stream_No from HMB_From_To h " \

                          f"inner join Stream_No s on s.UID=h.Stream_No_UID " \

                          f"where Drawing_UID = ?"

                    params = (drawing_uid,)

from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

from EngineeringErrorItem import QEngineeringErrorItem

from EngineeringEndBreakItem import QEngineeringEndBreakItem

from EngineeringUnknownItem import QEngineeringUnknownItem

from EngineeringRunItem import QEngineeringRunItem

    def find_item(scene, uid):

        items = [item for item in scene.items() if hasattr(item, 'uid') and str(item.uid) == str(uid)]

        return items[0] if items else None

    def set_stream_no(lineno, include_signal=True):

        """ modified from find_primary_lines at LineNoTracer"""

        connected_items = []

        _from = lineno.prop('From')

        _to = lineno.prop('To')

        if _from and _to and lineno.empty():

            connected_items = SetStreamCommand.find_connected_objects(_from, to=_to, primary=True, include_signal=include_signal)

            if _from in connected_items and _to in connected_items:

                start = connected_items.index(_from)

                end = connected_items.index(_to)

                if start < end:

                    connected_items = connected_items[start:end + 1]

                else:

                    connected_items = connected_items[end:start + 1]

                    connected_items.reverse()

        if connected_items:

            for item in connected_items:

                # set stream no -> on going

                pass

        return connected_items

    def find_connected_objects(start, to=None, primary=False, include_signal=True):

        visited = [start]

        break_at_first = None

        try:

            pool = []

            pool.append((0, start))

            while len(pool) > 0:

                sign, obj = pool.pop()

                match = False

                if not primary:

                    # check stream no is already setted

                    pass

                if issubclass(type(obj), QEngineeringEquipmentItem):

                    visited.pop(visited.index(obj))

                    continue

                elif match:

                    continue

                """ end loop if obj is to """

                if to is not None and str(obj.uid) == str(to.uid): break

                # nextmatches list always has one item

                if type(obj) is QEngineeringLineItem:

                    symbolMatches = [x for x in self._symbols if (x.owner is None or x.owner == start.owner) and (

                            x not in visited) and obj.is_connected(x)]

                    if include_signal:

                        lineMatches = [x for x in self._lines if

                                       (x.owner is None or x.owner == start.owner) and (x is not obj) and (

                                               x not in visited) and obj.is_connected(x)]

                    else:

                        lineMatches = [x for x in self._lines if

                                       x.is_piping() and (x.owner is None or x.owner == start.owner) and (

                                               x is not obj) and (x not in visited) and obj.is_connected(x)]

                    nextMatches = symbolMatches + lineMatches

                elif issubclass(type(obj), SymbolSvgItem):

                    # symbol can be connected with line and another symbol at the same time

                    if include_signal:

                        lineMatches = [x for x in self._lines if (x.owner is None or x.owner == start.owner) and (

                                x not in visited) and obj.is_connected(x)]

                    else:

                        lineMatches = [x for x in self._lines if

                                       x.is_piping() and (x.owner is None or x.owner == start.owner) and (

                                               x not in visited) and obj.is_connected(x)]

                    symbolMatches = [x for x in self._symbols if

                                     (x.owner is None or x.owner == start.owner) and (x is not obj) and (

                                             x not in visited) and obj.is_connected(x, None)]

                    nextMatches = symbolMatches + lineMatches

                    if len(nextMatches) > 1:  # choose one if connected items are more than 2

                        matches = [x for x in visited if obj.is_connected(x)]

                        if matches:

                            next_connected = [x for x in nextMatches if obj.next_connected(x, matches[0])]

                            if next_connected:

                                nextMatches = next_connected

                            else:

                                nextMatches = []

                    # if obj symbol has break connector and nextMatch connected that connector than break line group

                    if nextMatches and obj.break_connector and [index for index in obj.break_connector if

                                                                obj.connectors[index].connectedItem is nextMatches[0]]:

                        match = True

                        break

                # if obj item connected symbol that has break connector then break line group

                if nextMatches:

                    pop_index = []

                    index = 0

                    for nextMatch in nextMatches:

                        if hasattr(nextMatch, 'break_connector'):

                            if [index for index in nextMatch.break_connector if

                                nextMatch.connectors[index].connectedItem is obj]:

                                pop_index.append(index)

                        index += 1

                    for index in reversed(pop_index):

                        nextMatches.pop(index)

                        # order connected objects

                matches = []

                matches.extend(nextMatches)

                if sign == 0 and len(matches) > 1:

                    mid = int(len(matches) * 0.5)

                    lhs = matches[0:mid]

                    rhs = matches[mid:]

                elif sign == -1:

                    lhs = matches

                    rhs = []

                else:

                    lhs = []

                    rhs = matches

                for match in lhs:

                    # print(match)

                    pool.append((-1, match))

                    visited.insert(0, match)

                for match in rhs:

                    # print(match)

                    pool.append((1, match))

                    visited.append(match)

                # up to here

        except Exception as ex:

            from App import App

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

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

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

        # print(visited)

        return visited

            symbols = []

            lines = [item for item in scene.items() if type(item) is QEngineeringLineItem]

            lineNos = []

            spec_breaks = []

            end_breaks = []

            for end_break in [item for item in scene.items() if type(item) is QEngineeringEndBreakItem]:

                end_breaks.append(end_break)

            for item in scene.items():

                if type(item) is QEngineeringSpecBreakItem:

                    spec_breaks.append(item)

                elif issubclass(type(item), SymbolSvgItem) and not (type(item) is QEngineeringErrorItem) and not (

                        type(item) is QEngineeringUnknownItem) and item.type != 'Notes' and not (

                        type(item) is QEngineeringEndBreakItem):

                    symbols.append(item)

                elif type(item) is QEngineeringLineNoTextItem:

                    lineNos.append(item)

            rows = app_doc_data.get_stream_from_to(drawing_uid = app_doc_data.activeDrawing.UID)

            stream_nos = []

            for row in rows:

                stream_no = QEngineeringLineNoTextItem()

                stream_no.setPlainText(row['Stream_No'])

                from_item = SetStreamCommand.find_item(scene, row['From_Component_UID'])

                to_item = SetStreamCommand.find_item(scene, row['To_Component_UID'])

                if not from_item or not to_item:

                    continue

                stream_no.set_property('From', from_item)

                stream_no.set_property('To', to_item)

        hmbs = AppDocData.get_hmb_data(file_path)

                rows = AppDocData.get_hmb_data(None)

        hmbs = AppDocData.get_hmb_data(None)

            rows = app_doc_data.get_stream_from_to(hmb_uid=uid)