The first part wasn't too bad... once I realized you should store the ranges and not actually generate all the numbers o_O.

Seeds = list[int]
Map   = tuple[int, int, int]
Maps  = list[Map]

def read_almanac(stream=sys.stdin) -> tuple[Seeds, list[Map]]:
    seeds: Seeds = [int(seed) for seed in stream.readline().split(':')[-1].split()]
    maps:  Maps  = []

    for line in map(str.strip, stream):
        if line.endswith('map:'):
            maps.append([])
            continue
            
        try:
            dst, src, length = map(int, line.split())
        except ValueError:
            continue
            
        maps[-1].append((dst, src, length))

    return seeds, maps

def locate_seed(seed: int, maps: list[Map]) -> int:
    location = seed
    for amap in maps:
        for dst, src, length in amap:
            if src <= location < src + length:
                location = dst + (location - src)
                break
    return location

def main(stream=sys.stdin) -> None:
    seeds, maps = read_almanac(stream)
    locations   = [locate_seed(seed, maps) for seed in seeds]
    print(min(locations))

This part took me forever, mostly to actually run, but also to fix a few off-by-one errors :|

Fortunately, I was able to re-use most of my code in Part A and just add a new function to search the range of seeds.

Even with concurrent.futures and a 24-core machine, it still took me about 30 - 45 minutes to complete with Python (that said, there were only 10 seed range s in the input, so I could only use 10 cores, and of those 5 of the ranges appeared to be really large, leading to a long tail effect).

def locate_seeds(srange: Range, maps: list[Map]={}) -> int:
    seeds   = range(srange[0], srange[0] + srange[1])
    locator = functools.partial(locate_seed, maps=maps)
    return min(map(locator, seeds))

# Main Execution

def main(stream=sys.stdin) -> None:
    seeds, maps = read_almanac(stream)
    locator     = functools.partial(locate_seeds, maps=maps)

    with concurrent.futures.ProcessPoolExecutor() as executor:
        locations = executor.map(locator, batched(seeds, 2))

    print(min(locations))