Game = dict[str, int]

RED_MAX   = 12
GREEN_MAX = 13
BLUE_MAX  = 14

def read_game(stream=sys.stdin) -> Game:
    try:
        game_string, cubes_string = stream.readline().split(':')
    except ValueError:
        return {}

    game: Game = defaultdict(int)
    game['id'] = int(game_string.split()[-1])

    for cubes in cubes_string.split(';'):
        for cube in cubes.split(','):
            count, color = cube.split()
            game[color] = max(game[color], int(count))

    return game

def read_games(stream=sys.stdin) -> Iterator[Game]:
    while game := read_game(stream):
        yield game

def is_valid_game(game: Game) -> bool:
    return all([
        game['red']   <= RED_MAX,
        game['green'] <= GREEN_MAX,
        game['blue']  <= BLUE_MAX,
    ])

def main(stream=sys.stdin) -> None:
    valid_games = filter(is_valid_game, read_games(stream))
    sum_of_ids  = sum(game['id'] for game in valid_games)
    print(sum_of_ids)

For the second part, the main parsing remainded the same. I just had to change what I did with the games I read.

def power(game: Game) -> int:
    return game['red'] * game['green'] * game['blue']

def main(stream=sys.stdin) -> None:
    sum_of_sets = sum(power(game) for game in read_games(stream))
    print(sum_of_sets)

(Note lemmy removed some characters, code link shows them all)

use std::fs;

fn part1(input: String) -> i32 {
    const RED: i32 = 12;
    const GREEN: i32 = 13;
    const BLUE: i32 = 14;

    let mut sum = 0;

    for line in input.lines() {
        let [id, content] = line.split(": ").collect::>()[0..2] else { continue };
        let id = id.split(" ").collect::>()[1].parse::().unwrap();

        let marbles = content.split("; ").map(|x| { x.split(", ").collect::>() }).collect::>>();
        let mut valid = true;

        for selection in marbles {
            for marble in selection {
                let marble_split = marble.split(" ").collect::>();
                let marble_amount = marble_split[0].parse::().unwrap();
                let marble_color = marble_split[1];

                if marble_color == "red" && marble_amount > RED {
                    valid = false;
                    break;
                }

                if marble_color == "green" && marble_amount > GREEN {
                    valid = false;
                    break;
                }

                if marble_color == "blue" && marble_amount > BLUE {
                    valid = false;
                    break;
                }
            }
        }

        if !valid {
            continue;
        }

        sum += id;
    }

    return sum;
}

fn part2(input: String) -> i32 {
    let mut sum = 0;

    for line in input.lines() {
        let [id, content] = line.split(": ").collect::>()[0..2] else { continue };
        let id = id.split(" ").collect::>()[1].parse::().unwrap();

        let marbles = content.split("; ").map(|x| { x.split(", ").collect::>() }).collect::>>();
        
        let mut red = 0;
        let mut green = 0;
        let mut blue = 0;

        for selection in marbles {
            for marble in selection {
                let marble_split = marble.split(" ").collect::>();
                let marble_amount = marble_split[0].parse::().unwrap();
                let marble_color = marble_split[1];

                if marble_color == "red" && marble_amount > red {
                    red = marble_amount;
                }

                if marble_color == "green" && marble_amount > green {
                    green = marble_amount;
                }

                if marble_color == "blue" && marble_amount > blue {
                    blue = marble_amount;
                }
            }
        }

        sum += red * green * blue;
    }

    return sum;
}

fn main() {
    let input = fs::read_to_string("data/input.txt").unwrap();

    println!("{}", part1(input.clone()));
    println!("{}", part2(input.clone()));
}

with open('02A_input.txt', 'r') as file:
    data = file.readlines()
    
possibleGames=[]

for game in data:
    # Find Game number
    game = game.removeprefix("Game ")
    gameNumber = int(game[0:game.find(":")])
    # Break Game into rounds (split using semicolons)
    game=game[game.find(":")+1:]
    rounds=game.split(";")
    # For each round, determine the maximum number of Red, Blue, Green items shown at a time
    rgb=[0,0,0]
    for round in rounds:
        combos=round.split(",")
        for combo in combos:
            combo=combo.strip()
            number=int(combo[0:combo.find(" ")])
            if combo.endswith("red"):
                if number>rgb[0]:
                    rgb[0]=number
            elif combo.endswith("green"):
                if number>rgb[1]:
                    rgb[1]=number
            elif combo.endswith("blue"):
                if number>rgb[2]:
                    rgb[2]=number
    # If Red>12, Green>13, Blue>14, append Game number to possibleGames
    if not (rgb[0]>12 or rgb[1]>13 or rgb[2]>14):
        possibleGames.append(gameNumber)

print(sum(possibleGames))

with open('02A_input.txt', 'r') as file:
    data = file.readlines()
    
powers=[]

for game in data:
    # Find Game number
    game = game.removeprefix("Game ")
    # Break Game into rounds (split using semicolons)
    game=game[game.find(":")+1:]
    rounds=game.split(";")
    # For each round, determine the maximum number of Red, Blue, Green items shown at a time
    # Note: This could be faster, since we don't need to worry about actual rounds
    rgb=[0,0,0]
    for round in rounds:
        combos=round.split(",")
        for combo in combos:
            combo=combo.strip()
            number=int(combo[0:combo.find(" ")])
            if combo.endswith("red"):
                if number>rgb[0]:
                    rgb[0]=number
            elif combo.endswith("green"):
                if number>rgb[1]:
                    rgb[1]=number
            elif combo.endswith("blue"):
                if number>rgb[2]:
                    rgb[2]=number
    # Multiple R, G, B to find the "power" of the game
    # Append Power to the list
    powers.append(rgb[0]*rgb[1]*rgb[2])
    
print(sum(powers))

-- SPDX-FileCopyrightText: 2023 Jummit
--
-- SPDX-License-Identifier: GPL-3.0-or-later

local colors = {"blue", "red", "green"}
local available = {red = 12, blue = 14, green = 13}
local possible = 0
local id = 0
local min = 0

for game in io.open("2.input"):lines() do
  id = id + 1
  game = game:gsub("Game %d+: ", "").."; "
  local max = {red = 0, blue = 0, green = 0}
  for show in game:gmatch(".-; ") do
    for _, color in ipairs(colors) do
      local num = tonumber(show:match("(%d+) "..color))
      if num then
        max[color] = math.max(max[color], num)
      end
    end
  end
  min = min + max.red * max.blue * max.green
  local thisPossible = true
  for _, color in ipairs(colors) do
    if max[color] > available[color] then
      thisPossible = false
      break
    end
  end
  if thisPossible then
    possible = possible + id
  end
end

print(possible)
print(min)

// SPDX-FileCopyrightText: 2023 Jummit
//
// SPDX-License-Identifier: GPL-3.0-or-later

use strconv;
use types;
use strings;
use io;
use bufio;
use os;
use fmt;

const available: []uint = [12, 13, 14];

fn color_id(color: str) const uint = {
	switch (color) {
	case "red" => return 0;
	case "green" => return 1;
	case "blue" => return 2;
	case => abort();
	};
};

export fn main() void = {
	const file = os::open("2.input")!;
	defer io::close(file)!;
	const scan = bufio::newscanner(file, types::SIZE_MAX);
	let possible: uint = 0;
	let min: uint = 0;

	for (let id = 1u; true; id += 1) {
		const line = match(bufio::scan_line(&scan)!) {
		case io::EOF =>
			break;
		case let line: const str =>
			yield strings::sub(
					line,
					strings::index(line, ": ") as size + 2,
					strings::end);
		};
		let max: []uint = [0, 0, 0];
		let tok = strings::rtokenize(line, "; ");
		for (true) {
			const show = match(strings::next_token(&tok)) {
			case void =>
				break;
			case let show: str =>
				yield show;
			};
			const pairs = strings::tokenize(show, ", ");
			for (true) {
				const pair: (str, str) = match(strings::next_token(&pairs)) {
				case void =>
					break;
				case let pair: str =>
					let tok = strings::tokenize(pair, " ");
					yield (
						strings::next_token(&tok) as str,
						strings::next_token(&tok) as str
					);
				};
				let color = color_id(pair.1);
				let amount = strconv::stou(pair.0)!;
				if (amount > max[color]) max[color] = amount;
			};
		};
		if (max[0] <= available[0] && max[1] <= available[1] && max[2] <= available[2]) {
			fmt::printfln("{}", id)!;
			possible += id;
		};
		min += max[0] * max[1] * max[2];
	};
	
	fmt::printfln("{}", possible)!;
	fmt::printfln("{}", min)!;
};

public class Day2RoundInput { private Regex gameNumRegex = new Regex(“[a-z]* ([0-9]*)”, RegexOptions.IgnoreCase);

    public Day2RoundInput(string gameString)
    {
        var colonSplit = gameString.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries);
        var match = gameNumRegex.Match(colonSplit[0].Trim());
        var gameNumberString = match.Groups[1].Value;
        GameNumber = int.Parse(gameNumberString.Trim());

        HandfulsOfCubes = new List();
        var roundsSplit = colonSplit[1].Trim().Split(';', StringSplitOptions.RemoveEmptyEntries);
        foreach (var round in roundsSplit)
        {
            HandfulsOfCubes.Add(new HandfulCubes(round));
        }
    }
    public int GameNumber { get; set; }

    public List HandfulsOfCubes { get; set; }

    public class HandfulCubes
    {
        private Regex colourRegex = new Regex("([0-9]*) (red|green|blue)");

        public HandfulCubes(string roundString)
        {
            var colourCounts = roundString.Split(',', StringSplitOptions.RemoveEmptyEntries);
            foreach (var colour in colourCounts)
            {
                var matches = colourRegex.Matches(colour.Trim());

                foreach (Match match in matches)
                {
                    var captureOne = match.Groups[1];

                    var count = int.Parse(captureOne.Value.Trim());

                    var captureTwo = match.Groups[2];

                    switch (captureTwo.Value.Trim().ToLower())
                    {
                        case "red":
                            RedCount = count;
                            break;
                        case "green":
                            GreenCount = count;
                            break;
                        case "blue":
                            BlueCount = count;
                            break;
                        default: throw new Exception("uh oh");
                    }
                }
            }
        }

        public int RedCount { get; set; }
        public int GreenCount { get; set; }
        public int BlueCount { get; set; }
    }

}

internal class Day2Task1:IRunnable { public void Run() { var inputs = GetInputs();

        var maxAllowedRed = 12;
        var maxAllowedGreen = 13;
        var maxAllowedBlue = 14;

        var allowedGameIdSum = 0;

        foreach ( var game in inputs ) { 
            var maxRed = game.HandfulsOfCubes.Select(h => h.RedCount).Max();
            var maxGreen = game.HandfulsOfCubes.Select(h => h.GreenCount).Max();
            var maxBlue = game.HandfulsOfCubes.Select(h => h.BlueCount).Max();

            if ( maxRed <= maxAllowedRed && maxGreen <= maxAllowedGreen && maxBlue <= maxAllowedBlue) 
            {
                allowedGameIdSum += game.GameNumber;
                Console.WriteLine("Game:" + game.GameNumber + " allowed");
            }
            else
            {
                Console.WriteLine("Game:" + game.GameNumber + "not allowed");
            }
        }

        Console.WriteLine("Sum:" + allowedGameIdSum.ToString());

    }

    private List GetInputs()
    {
        List inputs = new List();

        var textLines = File.ReadAllLines("Days/Two/Day2Input.txt");

        foreach (var line in textLines)
        {
            inputs.Add(new Day2RoundInput(line));
        }

        return inputs;
    }

    
}

internal class Day2Task2:IRunnable { public void Run() { var inputs = GetInputs();

        var result = 0;

        foreach ( var game in inputs ) {
            var maxRed = game.HandfulsOfCubes.Select(h => h.RedCount).Max();
            var maxGreen = game.HandfulsOfCubes.Select(h => h.GreenCount).Max();
            var maxBlue = game.HandfulsOfCubes.Select(h => h.BlueCount).Max();

            var power = maxRed*maxGreen*maxBlue;
            Console.WriteLine("Game:" + game.GameNumber + " Result:" + power.ToString());

            result += power;
        }

        Console.WriteLine("Day2 Task2 Result:" + result.ToString());

    }

    private List GetInputs()
    {
        List inputs = new List();

        var textLines = File.ReadAllLines("Days/Two/Day2Input.txt");
        //var textLines = File.ReadAllLines("Days/Two/Day2ExampleInput.txt");

        foreach (var line in textLines)
        {
            inputs.Add(new Day2RoundInput(line));
        }

        return inputs;
    }

    
}