def METHOD_NAME(
    lc_model,
    requests: List[Union[str, Dict[str, Any]]] = None,
    max_workers: int = 10,
):
    """
    Processes API requests in parallel.
    """
    # initialize trackers
    retry_queue = queue.Queue()
    status_tracker = StatusTracker()  # single instance to track a collection of variables
    next_request = None  # variable to hold the next request to call
    results: list[tuple[int, str]] = []
    requests_iter = enumerate(requests)
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        while True:
            # get next request (if one is not already waiting for capacity)
            if next_request is None:
                if not retry_queue.empty():
                    next_request = retry_queue.get_nowait()
                    _logger.warning(f"Retrying request {next_request.index}: {next_request}")
                elif req := next(requests_iter, None):
                    # get new request
                    index, request_json = req
                    next_request = APIRequest(
                        index=index, lc_model=lc_model, request_json=request_json, results=results
                    )
                    status_tracker.start_task()
            # if enough capacity available, call API
            if next_request:
                # call API
                executor.submit(
                    next_request.call_api,
                    status_tracker=status_tracker,
                )
                next_request = None  # reset next_request to empty
            # if all tasks are finished, break
            if status_tracker.num_tasks_in_progress == 0:
                break
            time.sleep(0.001)  # avoid busy waiting
        # after finishing, log final status
        if status_tracker.num_tasks_failed > 0:
            raise mlflow.MlflowException(
                f"{status_tracker.num_tasks_failed} tasks failed. See logs for details."
            )
        return [res for _, res in sorted(results)]