---
# System prepended metadata

title: llmcompiler & playwright async

---

# llmcompiler & playwright async

### partial solution for the thread problem:
making llmcompiler async works unless a playwright tool get data from a different thread. for example:
```
{'idx': 1, 'tool': GoogleSerperResultsFixedV2(), 'args': {'query': 'IceCube collaboration meeting committees', 'result_index': 0, 'result_location': 'US', 'result_language': 'en'}, 'dependencies': [], 'thought': None}
---> async serper cache is not used
{'idx': 2, 'tool': NavigateTool(description='navigate_browser() - PlayWright browser tool - Navigate a browser to the specified URL', async_browser=<Browser type=<BrowserType name=chromium executable_path=/Users/dpc/Library/Caches/ms-playwright/chromium-1124/chrome-mac/Chromium.app/Contents/MacOS/Chromium> version=127.0.6533.17>), 'args': {'url': '$1'}, 'dependencies': [1], 'thought': None}
{'idx': 3, 'tool': ExtractTextTool(description='extract_text() - PlayWright browser tool - Extract all the text on the current webpage NOTE: This tool only extracts text from the last navigated website.So to use function, the website of interest should be navigated first.', async_browser=<Browser type=<BrowserType name=chromium executable_path=/Users/dpc/Library/Caches/ms-playwright/chromium-1124/chrome-mac/Chromium.app/Contents/MacOS/Chromium> version=127.0.6533.17>), 'args': (), 'dependencies': [], 'thought': None}
{'idx': 4, 'tool': 'join', 'args': (), 'dependencies': [1, 2, 3], 'thought': None}
```

causes

`Error: ValueError('Browser.new_context: The future belongs to a different loop than the one specified as the loop argument')`

the same code works in pycharm debug mode :/


### !!!! Solution with (monkey) patching
this error happens since async playwright browser creates own event loop

```
import nest_asyncio
nest_asyncio.apply()
```

This code patches asyncio to allow nested use of asyncio.run and loop.run_until_complete, playwright causes, and async llmcompiler works in this way.

This solution is also suggested in [langchain's playwright docs](https://python.langchain.com/v0.1/docs/integrations/toolkits/playwright/).

### 1. gpt-4o's opinions about this patching technique:

> #### Considerations for Using `nest_asyncio.apply()`
> 
> 1. **Complexity**:
>    - **Increased Complexity**: Nesting event loops can add complexity to your code, making it harder to understand and debug. Ensure that you and your team are comfortable with the added complexity.
> 
> 2. **Compatibility**:
>    - **Library Compatibility**: Not all third-party libraries may work seamlessly with `nest_asyncio`. Thoroughly test the third-party library to ensure it behaves as expected when nested within your asyncio context.
> 
> 3. **Performance**:
>    - **Potential Performance Impact**: There might be performance implications when using nested event loops, especially if the third-party library is I/O-bound or CPU-intensive. Monitor the performance to ensure it meets your requirements.
> 
> 4. **Maintenance**:
>    - **Maintenance Challenges**: Using `nest_asyncio` can make your code less portable and harder to maintain, particularly if other developers are not familiar with the library. Document the use of `nest_asyncio` clearly to aid future maintenance.
> 
> 5. **Debugging**:
>    - **Debugging Complexity**: Nesting event loops can complicate debugging. Be prepared for potential challenges in diagnosing issues related to nested event loops.
> 
> 6. **Portability**:
>    - **Reduced Portability**: The use of `nest_asyncio` may reduce the portability of your code, as it introduces a dependency that may not be present in all environments. Ensure that the environments where your code will run can support `nest_asyncio`.
> 
> #### Conclusion
> 
> Using `nest_asyncio.apply()` can be a practical solution for handling nested event loops, especially when dealing with third-party libraries that create their own event loops. However, it is important to carefully consider the added complexity, compatibility, performance implications, and maintenance challenges. Thorough testing and clear documentation are essential to ensure that your code remains robust and maintainable.


### 2. summary (gpt-4o) of related nest_asyncio official [issue](https://github.com/erdewit/nest_asyncio/issues/36)

> ### Tradeoffs of Using `nest_asyncio`
> 
> - **Performance Impact**: The performance impact of using `nest_asyncio` can vary. For some use cases, it is negligible, while for others, especially with PyPy, it can be faster than the unnested variant. However, it is recommended to measure performance for your specific use case.
> - **Compatibility**: `nest_asyncio` allows for the use of nested event loops, which is not natively supported by `asyncio`. This can be particularly useful in environments like Jupyter notebooks where nested event loops are common.
> - **Fairness and Starvation**: There are concerns about fairness and potential starvation of tasks. If a nested `asyncio.run` call is made, it can block or starve previously scheduled tasks on the event loop. This is because `asyncio.run` is synchronous and does not yield control back to the event loop.
> - **Use Case Limitations**: The library is often used as a hack to get things working in environments that require nested event loops. However, it is not a solution for concurrency and can lead to subtle bugs and issues, especially in larger codebases.
> - **Comparison with Gevent**: Unlike `nest_asyncio`, `gevent` is designed to handle nested calls without blocking previously scheduled tasks. `gevent` uses cooperative multitasking, which can be more suitable for certain use cases.
> - **Documentation and Community Confusion**: There is a significant amount of confusion in the community regarding the use of `nest_asyncio`. Proper documentation and understanding of its limitations are crucial to avoid difficult-to-debug issues.
> 
> #### Example Code
> ```python
> import nest_asyncio
> nest_asyncio.apply()
> import asyncio
> 
> async def echo(x):
>     for i in range(0, 5):
>         print(x, i)
>         await asyncio.sleep(1)
> 
> def testNested():
>     for i in range(0, 5):
>         asyncio.get_event_loop().create_task(echo(i))
>     inner()
> 
> def inner():
>     for i in range(5, 10):
>         asyncio.get_event_loop().create_task(echo(i))
>     asyncio.run(asyncio.sleep(20))
> 
> testNested()
> ```
> In this example, the nested `asyncio.run` call can block other tasks, demonstrating the potential for starvation.