> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-1778-mysql-updates.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# util
> Python SDK reference for weave.trace.util
# API Overview
***
## class `ContextAwareThreadPoolExecutor`
A ThreadPoolExecutor that runs functions with the context of the caller.
This is a drop-in replacement for concurrent.futures.ThreadPoolExecutor that ensures weave calls behave as expected inside the executor. Weave requires certain contextvars to be set (see call\_context.py), but new threads do not automatically copy context from the parent, which can cause the call context to be lost -- not good! This class automates contextvar copying so using this executor "just works" as the user probably expects.
You can achieve the same effect without this class by instead writing:
```python theme={null}
with concurrent.futures.ThreadPoolExecutor() as executor:
contexts = [copy_context() for _ in range(len(vals))]
def _wrapped_fn(*args):
return contexts.pop().run(fn, *args)
executor.map(_wrapped_fn, vals)
```
### method `__init__`
```python theme={null}
__init__(*args: 'Any', **kwargs: 'Any') → None
```
***
### method `map`
```python theme={null}
map(
fn: 'Callable',
*iterables: 'Iterable[Any]',
timeout: 'float | None' = None,
chunksize: 'int' = 1
) → Iterator
```
***
### method `submit`
```python theme={null}
submit(fn: 'Callable', *args: 'Any', **kwargs: 'Any') → Any
```
***
## class `ContextAwareThread`
A Thread that runs functions with the context of the caller.
This is a drop-in replacement for threading.Thread that ensures calls behave as expected inside the thread. Weave requires certain contextvars to be set (see call\_context.py), but new threads do not automatically copy context from the parent, which can cause the call context to be lost -- not good! This class automates contextvar copying so using this thread "just works" as the user probably expects.
You can achieve the same effect without this class by instead writing:
```python theme={null}
def run_with_context(func, *args, **kwargs):
context = copy_context()
def wrapper():
context.run(func, *args, **kwargs)
return wrapper
thread = threading.Thread(target=run_with_context(your_func, *args, **kwargs))
thread.start()
```
### method `__init__`
```python theme={null}
__init__(*args: 'Any', **kwargs: 'Any') → None
```
***
#### property daemon
A boolean value indicating whether this thread is a daemon thread.
This must be set before start() is called, otherwise RuntimeError is raised. Its initial value is inherited from the creating thread; the main thread is not a daemon thread and therefore all threads created in the main thread default to daemon = False.
The entire Python program exits when only daemon threads are left.
***
#### property ident
Thread identifier of this thread or None if it has not been started.
This is a nonzero integer. See the get\_ident() function. Thread identifiers may be recycled when a thread exits and another thread is created. The identifier is available even after the thread has exited.
***
#### property name
A string used for identification purposes only.
It has no semantics. Multiple threads may be given the same name. The initial name is set by the constructor.
***
#### property native\_id
Native integral thread ID of this thread, or None if it has not been started.
This is a non-negative integer. See the get\_native\_id() function. This represents the Thread ID as reported by the kernel.
***
### method `run`
```python theme={null}
run() → None
```