HYTOS

        try:

            sizeUnit = None

            configs = AppDocData.instance().getConfigs('Project', 'Unit')

            sizeUnit = configs[0].value if 1 == len(configs) else 'Imperial'

            pipe_sizes = NominalPipeSizeTable.instance().pipe_sizes

            text = text.replace("'", '"').replace(' ', '').upper()

            if delimiter != '/' and delimiter in text:

                if len([_text for _text in text.split(delimiter.upper()) if len(_text) > 0]) < 2:

                    return False

                if text.count(delimiter) != 1:

                    return False

            first, second = None, None

            # for imperial

            if sizeUnit == 'Imperial' and text.find('"') is not -1 and delimiter == '/':

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

                second = text[text.find('"') + 1:].replace(delimiter.upper(), '',

                                            1).strip() if delimiter is not None else text[text.find('"') + 1:].strip()

            elif sizeUnit == 'Imperial':

                first = text.split(delimiter.upper())[0]

                second = text.split(delimiter.upper())[1] if len(text.split(delimiter.upper())) == 2 else None

            # for metric

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

                if len(split_text) > 2:

                    return False

                first = split_text[0]

                second = split_text[1] if len(split_text) is 2 else None

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

            index = 0

            for token in tokens:

                matches = [(sizeData.find(token, sizeUnit) if sizeUnit else sizeData.find(token)) for sizeData in pipe_sizes

                        if (sizeData.find(token, sizeUnit) if sizeUnit else sizeData.find(token))]

                if matches:

                    tokens[index] = matches[0]

                else:

                    return False

                index += 1

            if len(tokens) == 2:

                if self.inch_to_number(tokens[0]) < self.inch_to_number(tokens[1]):

                    tokens[0], tokens[1] = tokens[1], tokens[0]

            return [delimiter.join(tokens), tokens, delimiter]

        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)

            return False

        try:

            app_doc_data = AppDocData.instance()

            configs = app_doc_data.getConfigs('Size', 'Symbol')

            size_symbols = configs[0].value.replace(' ', '').split(',') if 1 == len(configs) else ['"']

            inch_str = str(inch_str)

            for symbol in size_symbols:

                inchs = inch_str.replace(symbol, '')

            inchs = inchs.replace('"', '').split('-')

            number = 0

            for inch in inchs:

                if '/' not in inch:

                    number += float(inch)

                else:

                    fraction = inch.split('/')

                    number += float(fraction[0]) / float(fraction[1])

        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)

            return 0