The head block doesn't terminate the flowgraph execution with connection with modulator

[Marcin Puchlik]

I encountered a problem when blocks.head() object doesn't terminate flowgraph execution when I used digital.generic_mod() object inside the same flowgraph. The problem was also described here: https://dsp.stackexchange.com/questions/75371/gnu-radio-head-block-doesnt-finish-simulation?noredirect=1#comment160051_75371. Is there any reason that those blocks are not compatible with themselves? I encountered the same issue while writing the code from the scratch:

from gnuradio import gr
from gnuradio import blocks
from gnuradio import analog
from gnuradio import digital
import numpy as np
import matplotlib.pyplot as plt



class transmitter_base(gr.hier_block2):
    def __init__(self, samples_count):
        # constructor my class
        # call constructor for parent class
        gr.hier_block2.__init__(self, name="transmitter_base", input_signature=gr.io_signature(0,0,0), output_signature=gr.io_signature(1,1,gr.sizeof_gr_complex))
        # Create random bits generator for modulator input - output of the random generator should by unsigned char
        self.bits_generator = analog.random_uniform_source_b(0, 256, np.random.randint(low = -2_147_483_647, high = 2_147_483_647)) # return and int from range [0, 256)
        self.limiter = blocks.head(gr.sizeof_gr_complex, samples_count)
       
        # self.connect(self.src, self.head, self) Note: connect in derived class
class bpsk_transmitter(transmitter_base):
    def __init__(self,samples_count, sps, alpha):
        transmitter_base.__init__(self, samples_count)
        # Here declare blocks that based on bit sequence generate BPSK waveform
        # self.mod = digital.generic_mod()
        self.mod = digital.generic_mod(digital.constellation_bpsk(), False, sps, False, alpha, True, False, False)
        self.connect(self.bits_generator,self.mod, self.limiter, self)
       
def main():
    my_bpsk_modulator = bpsk_transmitter(1000, 8, 0.35)
    sink = blocks.vector_sink_c()
    tb = gr.top_block()
    tb.connect(my_bpsk_modulator, sink)
    tb.run()
    raw_output_vector = np.array(sink.data(), dtype=np.complex64)
    plt.plot(np.real(raw_output_vector))
    plt.plot(np.imag(raw_output_vector))
       
if  __name__ == '__main__':
    main()

Kind regards,

Marcin Puchlik