Scoop | stack trace when an app crashes | Android library

Minimized self-contained example:

The main idea behind your problem is that you do not subscribe to the changes of your ServicesProvider. You can replace Provider.of(context, listen: false); with context.read(); that is a more concise syntax using extension methods.

Based on the Provider documentation:

context.read(), which returns T without listening to it. <...> It's worth noting that context.read() won't make a widget rebuild when the value changes and it cannot be called inside StatelessWidget.build/State.build. On the other hand, it can be freely called outside of these methods.

What you have done already with final myModel = Provider.of(context, listen: false); is that you only retrieved the reference to ServicesProvider. However, this way you do not subscribe to the changes inside the model - this is exactly what the documentation explains.

To resolve this, you can move the AlertDialog into a separate widget, e.g. MyDialog. There is a practical reason - it's just easier to understand that now you are not using the same context and you should access the re-provided ServicesProvider model. Now, by using context.watch() (you could use the Consumer widget as well if you would like to), you can subscribe to the changes of your model. Thus, when there is a change for the paymentMethod value inside the model (you can do it by calling the setPaymentMethod() method on model), it triggers UI rebuild (notifyListeners() does its work) and you get the expected output.

You could find the recreated and resolved issue here.

JAVA_HOME=C:\Program Files\Java\jdk-17.0.2

Drop the "bin"

The text inside an HTML tag can be interrupted by a number of things, not just CDATA sections. It could contain entity references, or numerical entity references. It could contain comments, which will mostly be ignored, or it could contain content-less tags which are not of interest to the parser. And so on. A lexer which eliminated those things might be useful in a particular context, or it might create a problem which the lexer's client will end up tearing their hair out trying to solve. On the whole, these are issues the lexer should probably not attempt to solve; it's better design to just document the fact that text might be lexed as several consecutive TEXT tokens (or several consecutive "text-like" tokens). That's certainly the way I would do it.

I understand that you're trying to take advantage of Flex's internal buffer to do the token concatenation in place, avoiding extra memory allocation and copying. That's a tempting optimisation, but it drops you into a twisty maze of details and corner cases. Furthermore, Flex is designed around the idea that tokens are "not too long"; extremely long tokens can trigger inefficiencies in the Flex algorithm.

There are well-known techniques for optimising string assembly, and you'd probably be better off using one of them (or a library which implements efficient string concatenation) and leave Flex's internals to Flex. :-)

I think the issue might be that zx is using the bash inside WSL. Assuming you also don't want to use ffmpeg in WSL, here is how I fixed it.

1. Install git.
2. Find the bash.exe inside the installed git. In my case, it is located at C:/Program Files/Git/usr/bin/bash.exe.
3. Insert the following line after the shebang: $.shell = `Location to your bash`. In my case, it is $.shell = `C:/Program Files/Git/usr/bin/bash.exe`;.

I am fairly sure this works with other distributions of bash for Windows, but I have not tested.

You could use json module to parse content of script tags, which is accessible by .text field

Here is the example of parsing all script jsons and printing name:

Simple solution

With code like this, you need to be extra careful to specify which python you are referring to

p = subprocess.run(["python", "-m scoop", "run.py"])

When you do this, you will get the version of Python that is on your system path, not necessarily the venv that you are using.

You are better off running the line as p = subprocess.run(["/path/to/python", "-m scoop", "run.py"])

Edit: You could also run something like this to detect the executable that the Streamlit code is running under

subprocess.run([f"{sys.executable} ", "-m scoop", "run.py"])

Up front, I'm generally against writing functions that defeat functional reproducibility, having spent too much time troubleshooting functions that change behavior based on something not passed to them.

However, try this: