Add support for splitting a pattern-repeating problem

import datetime

import json

import math

import os

import queue

import re

        return _text

    @property

    def group_problem_text(self):

        group_problems = list()

        for g in self.block_groups:

            problem_text = ''

            num_tiles = 0

            line_remap_list = list()

            block_text = ''

            for bi, bn in enumerate(g):

                b = self.blocks[bn]

                num_tiles += b['num_tiles']

                block_text += f'BLOCK#{bi+1} {b["w"]}X{b["h"]}\n'

                for br in b['cells']:

                    br_cells = list()

                    for bc in br:

                        if isinstance(bc, int) and bc > 0:

                            if not bc in line_remap_list:

                                line_remap_list.append(bc)

                            remapped_index = line_remap_list.index(bc) + 1

                            br_cells.append(str(remapped_index))

                        else:

                            br_cells.append(str(bc))

                    block_text += ','.join(br_cells) + '\n'

                block_text += '\n'

            board_xy = math.ceil(2 * math.sqrt(num_tiles))

            problem_text += f'SIZE {board_xy}X{board_xy}\n'

            problem_text += f'BLOCK_NUM {len(g)}\n'

            problem_text += '\n'

            problem_text += block_text

            group_problems.append(problem_text)

        return group_problems

    @property

    def status(self):

        _status = 'None'

                    'index': bi,

                    'w': bw,

                    'h': bh,

                    'cells': list()

                    'cells': list(),

                    'num_tiles': 0

                }

                num_block_tile = 0

                for _h in range(bh):

                    li += 1

                    _l = q_lines[li].strip()

                            if not _line_num in line_number_list:

                                line_number_list.append(_line_num)

                            # _line_num = line_number_list.index(_line_num)

                            tile_num += 1

                            num_block_tile += 1

                            # Make connection list

                            if not bi in block_to_line:

                            if not _line_num in line_to_block:

                                line_to_block[_line_num] = list()

                            line_to_block[_line_num].append(bi)

                        elif _line_num == '+':

                            num_block_tile += 1

                        _block_row.append(_line_num)

                    blocks[bi]['cells'].append(_block_row)

                    # blocks[bi]['cells'].append([intplus(v.strip()) for v in _l.split(',')])

                blocks[bi]['num_tiles'] = num_block_tile

                tile_num += num_block_tile

            li += 1

        self.problem = q_text

        self.line_numbers = line_number_list

        self.connection = (line_to_block, block_to_line)

        # self.status = 'Ready'

        self._analyze_block_groups()

            'size_str': self.size_str,

            'block_num': self.block_num,

            'problem': self.problem,

            # 'status': self.status

            'group_problems': self.group_problem_text,

            'status': self.status

        }

    def get_d3json(self):