Pretty straightforward. Took advantage of itertools.pairwise.

def predict(history: list[int]) -> int:
    sequences = [history]
    while len(set(sequences[-1])) > 1:
        sequences.append([b - a for a, b in itertools.pairwise(sequences[-1])])
    return sum(sequence[-1] for sequence in sequences)

def main(stream=sys.stdin) -> None:
    histories   = [list(map(int, line.split())) for line in stream]
    predictions = [predict(history) for history in histories]
    print(sum(predictions))

Only thing that changed from the first part was that I used functools.reduce to take the differences of the first elements of the generated sequences (rather than the sum of the last elements for Part 1).

def predict(history: list[int]) -> int:
    sequences = [history]
    while len(set(sequences[-1])) > 1:
        sequences.append([b - a for a, b in itertools.pairwise(sequences[-1])])
    return functools.reduce(
        lambda a, b: b - a, [sequence[0] for sequence in reversed(sequences)]
    )

def main(stream=sys.stdin) -> None:
    histories   = [list(map(int, line.split())) for line in stream]
    predictions = [predict(history) for history in histories]
    print(sum(predictions))

import fs from "fs";

const rows = fs.readFileSync("./09/input.txt", "utf-8")
    .split(/[\r\n]+/)
    .map(row => row.trim())
    .filter(Boolean)
    .map(row => row.split(/\s+/).map(number => parseInt(number)));

console.info("Part 1: " + solve(structuredClone(rows)));
console.info("Part 2: " + solve(structuredClone(rows), true));

function solve(rows: number[][], part2 = false): number {
    let total = 0;
    for (const row of rows) {
        const sequences: number[][] = [row];
        while (sequences[sequences.length - 1].some(number => number !== 0)) { // Loop until all are zero
            const lastSequence = sequences[sequences.length - 1];
            const newSequence: number[] = [];
            for (let i = 0; i < lastSequence.length; i++) {
                if (lastSequence[i + 1] !== undefined) {
                    newSequence.push(lastSequence[i + 1] - lastSequence[i]);
                }
            }
            sequences.push(newSequence);
        }

        // For part two just reverse the sequences
        if (part2) {
            sequences.forEach(sequence => sequence.reverse());
        }

        // Add the first zero manually and loop the rest
        sequences[sequences.length - 1].push(0);
        for (let i = sequences.length - 2; i >= 0; i--) {
            sequences[i].push(part2
                ? sequences[i][sequences[i].length - 1] - sequences[i + 1][sequences[i + 1].length - 1]
                : sequences[i][sequences[i].length - 1] + sequences[i + 1][sequences[i + 1].length - 1]
            );
        }
    
        total += sequences[0].reverse()[0];
    }

    return total;
}

import re
import math
import argparse
import itertools

#https://stackoverflow.com/a/1012089
def iter_item_and_next(iterable):
    items, nexts = itertools.tee(iterable, 2)
    nexts = itertools.chain(itertools.islice(nexts, 1, None), [None])
    return zip(items, nexts)

class Sequence:
    def __init__(self,sequence:list) -> None:
        self.list = sequence
        if all([x == sequence[0] for x in sequence]):
            self.child:Sequence = ZeroSequence(len(sequence)-1)
            return
        
        child_sequence = list()
        for cur,next in iter_item_and_next(sequence):
            if next == None:
                continue
            child_sequence.append(next - cur)

        if len(child_sequence) > 1:
            self.child:Sequence = Sequence(child_sequence)
            return
        
        # can't do diff on single item, use zero list
        self.child:Sequence = ZeroSequence(1)

    def __repr__(self) -> str:
        return f"Sequence([{self.list}], Child:{self.child})"

    def getNext(self) -> int:
        if self.child == None:
            new = self.list[-1]
        else: 
            new = self.list[-1] + self.child.getNext()

        self.list.append(new)
        return new
    
    def getPrevious(self) -> int:
        if self.child == None:
            new = self.list[0]
        else: 
            new = self.list[0] - self.child.getPrevious()

        self.list.insert(0,new)
        return new

class ZeroSequence(Sequence):
    def __init__(self,count) -> None:
        self.list = [0]*count
        self.child = None

    def __repr__(self) -> str:
        return f"ZeroSequence(length={len(self.list)})"

    def getNext(self) -> int:
        self.list.append(0)
        return 0
    
    def getPrevious(self) -> int:
        self.list.append(0)
        return 0

def parse_line(string:str) -> list:
    return [int(x) for x in string.split(' ')]

def main(line_list):
    data = [Sequence(parse_line(x)) for x in line_list]
    print(data)

    # part 1
    total = 0
    for d in data:
        total += d.getNext()
    print("Part 1 After:")
    print(data)
    print(f"part 1 total: {total}")

    # part 2
    total = 0
    for d in data:
        total += d.getPrevious()
    print("Part 2 After:")
    print(data)
    print(f"part 2 total: {total}")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="day 1 solver")
    parser.add_argument("-input",type=str)
    parser.add_argument("-part",type=int)
    args = parser.parse_args()
    filename = args.input
    if filename == None:
        parser.print_help()
        exit(1)
    file = open(filename,'r')
    main([line.rstrip('\n') for line in file.readlines()])
    file.close()