Closing: GNU Radio 3.9.3.0 Python basic block - issues with, forecast and produce

Hello Johannes and hello Marcus,

thank you both for the suggestions and explanations, it really helps a
lot and is much appreciated!
With your explanations, I was able to produce my minimal working
example, which I have linked below.

> The best place to check for specifics about Python blocks is here:
> https://github.com/gnuradio/gnuradio/blob/main/gnuradio-runtime/python/gnuradio/gr/gateway.py
>
> This is the interface that is implemented. The `forecast` method is
> implemented in L153ff. It is different from the C++ version.
Thanks for this hint, I've taken a look at the implementation. Also
thanks for the suggestion with `bpython3` it is a really nice tool. For
now my block works without the `forecast` method so I won't bother
implementing it for now. I think it makes more sense to implement
`forecast` if I should decide to work with a C++ block.


> The mechanism is that the scheduler asks forecast what it needs to produce the largest
> amount of output that the output buffer can deal with, then it halves the amount until it
> hits the minimum number. If none of these requests yield a fulfillable input requirement,
> the block is permanently input-blocked.
Also thanks for clearing this up and explaining it Marcus!


> First off, the `consume_each` call needs to go behind any read on the
> input buffer. You really tell the system at this point: I'm finally done
> with these items, do whatever. Since GR is a multi-threaded system, this
> may cause trouble because the samples you want to read are already
> overwritten.
>
>
> So let's comment on your `general_work`.
>
> > def general_work(self, input_items, output_items):
> > # Firstly check, if input_items has a sufficient amount of items
> > if len(input_items[0]) >= self.buffer_len:
> > # Then consume exactly self.buffer_len items
> > self.consume_each(self.buffer_len)
> `consume_each` should go after the last use of `input_items`.
The comment, together with your explanation makes perfect sense, I have
changed it accordingly.


> > # Now only output a fraction of the input items, say the first
> > self.out_items, on output port[0]
> > output_items[0] = input_items[0][:self.out_items]
> This is probably the line causing issues. Try
> `output_items[0][0:self.out_items] = input_items[0][0:self.out_items]`
> The difference is the left hand indexing. Now, you write items to
> positions in an array. Previously, you overwrote the array and replaced
> it with a new one. Thus, the output buffer was still full of zeros.

Changing this line was the last missing piece, the minimal example now
works! I have posted my working minimal example here:
https://pastebin.com/qxgnPcpL


And with that I would like to close this problem, thanks again for the
feedback!


Kind regards,
Patric