UnboundLocalError: cannot access local variable 'batch' where it is not associated with a value

import json
from datetime import datetime

from dateutil import parser
from freight_request_processor import get_distance_mapping, process_single
from freight_request_repository import save_requests_pg
from more_itertools import chunked
from prefect import flow, get_run_logger, task, unmapped
from prefect.blocks.system import Secret
from prefect.cache_policies import NO_CACHE
from prefect.task_runners import ThreadPoolTaskRunner
from timocom import Timocom
from utils import (
    build_pg_utils_from_block,
    get_config,
    parse_location_criteria,
    publish_refresh_message,
)

@flow(task_runner=ThreadPoolTaskRunner())
def timocom_search_flow(
    search_parameters: dict,
    pg_secret_block: str,
    timocom_secret_block: str,
    rabbitmq_secret_block: str,
    ors_server_variable: str,
    price_calculation_server_variable: str,
    predictive_scoring_server_variable: str,
    here_maps_api_key_variable: str,
):
    logger = get_run_logger()
    <http://logger.info|logger.info>(f"Starting Timocom search with parameters: {search_parameters} at {datetime.now()}")

    try:
        sanitized_search_parameters = sanitize_and_validate_search_parameters(search_parameters)
        pg_utils = build_pg_utils_from_block(pg_secret_block)

        # Perform Timocom search

        # Timocom credentials are stored as "tenant_id": {"user": "username", "pass": "password"}
        creds = Secret.load(timocom_secret_block).get()
        tenant_ref = sanitized_search_parameters["tenant_ref"]
        <http://logger.info|logger.info>(f"Using Timocom credentials for tenant: {tenant_ref}")
        tenant_creds = creds.get(tenant_ref)
        if not tenant_creds:
            raise ValueError(f"No Timocom credentials found for tenant {tenant_ref}")

        user = tenant_creds["user"]
        password = tenant_creds["pass"]

        # Initialize Timocom instance
        timocom_instance = Timocom(logger, pg_utils, user, password)
        # Create search tasks
        search_tasks = timocom_instance.create_search_tasks(sanitized_search_parameters)
        search_futures = timocom_instance.search.map(search_tasks)

        <http://logger.info|logger.info>("Timocom search process completed.")

        config = get_config(
            ors_server_variable,
            price_calculation_server_variable,
            predictive_scoring_server_variable,
            here_maps_api_key_variable,
        )

        for future in search_futures:
            for batch in chunked(future.result(), 50):
                <http://logger.info|logger.info>(f"Processing batch of {len(batch)} results...")

                distance_mapping = get_distance_mapping(batch, config)

                proccessed_results = process_single.map(unmapped(config), batch, distance_mapping)
                <http://logger.info|logger.info>("Post-processing of freight requests completed.")

                save_requests_pg(proccessed_results, logger, pg_secret_block)

                <http://logger.info|logger.info>("Requests data persistence completed.")
                <http://logger.info|logger.info>(f"Publish message: {datetime.now()}")
                publish_refresh_message(
                    rabbitmq_secret_block,
                    search_parameters["tab_id"],
                    search_parameters["job_id"],
                    "REFRESH",
                )

    except Exception as e:
        logger.error(f"Error during Timocom search initiation: {e}")
        publish_refresh_message(
            rabbitmq_secret_block, search_parameters["tab_id"], search_parameters["job_id"], "FAILED"
        )
        raise