@sylee957, with an infinite grammar, you can use the depth parameter to limit the recursion depth:

gen = generate(G, depth=10)
print(next(gen))

['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']

I think that it also has the problem if it doesn't reach 'aa', 'aaa', 'aaaa', ...

@sylee957 actually, given a finite value for 'depth' lower than the recursion limit, the generate function does reach all the allowable productions. Since it concatenates lists and not strings, it outputs forms like ['a', 'a'] instead of 'aa'. And since it applies the grammar depth-first, the first output is the deepest tree, while the breadth-first strategy would start with ['a'].

For example:

n = 5
gen = generate(G, depth=n)
for _i in range(n):
    print(next(gen))

['a', 'a', 'a', 'a']
['a', 'a', 'a']
['a', 'a']
['a']
[]

So the real problem seems to be that, at line 29, generate.py sets a default depth that is much higher than the recursion limit:

    if depth is None:
        depth = sys.maxsize

However, using sys.getrecursionlimit() instead, which is 1000, is also still too high.
With the above grammar, the highest usable depth was 331 for me. Maybe the reason for this could be that the indirect recursions between _generate_all() and _generate_one() are adding up towards the recursion limit. If that is the reason, the maximum possible depth could be a little less than a third of the recursion limit.

Then, the solution could be, on one hand, to lower the default depth and, on the other hand, to output a more informative warning when the recursion limit is reached,
and mention the possibility of raising that value, using sys.setrecursionlimit().