Use ruff for Python formatting/linting

Author: sanderploegsma

.gitignore

@@ -20,3 +20,4 @@ target
 *.pyc
 __pycache__
 .pytest_cache
+.ruff_cache

2020/python/aoc_2020/day01.py

@@ -2,13 +2,15 @@
 from itertools import permutations
 from operator import mul
 
-input = open('2020/input/day01.txt').read()
+input = open("2020/input/day01.txt").read()
 numbers = [int(x) for x in input.splitlines()]
 
+
 def find_numbers_with_total_sum(total, n):
     candidates = permutations(numbers, n)
     matches = filter(lambda x: sum(x) == total, candidates)
     return next(matches)
 
-print('part one: %d' % reduce(mul, find_numbers_with_total_sum(2020, 2)))
-print('part two: %d' % reduce(mul, find_numbers_with_total_sum(2020, 3)))
+
+print("part one: %d" % reduce(mul, find_numbers_with_total_sum(2020, 2)))
+print("part two: %d" % reduce(mul, find_numbers_with_total_sum(2020, 3)))

2020/python/aoc_2020/day02.py

@@ -1,25 +1,29 @@
 def parse_line(line):
     policy, password = line.split(": ")
-    rule, target = policy.split(' ')
-    a, b = [int(x) for x in rule.split('-')]
+    rule, target = policy.split(" ")
+    a, b = [int(x) for x in rule.split("-")]
 
     return a, b, target, password
 
-input = open('2020/input/day02.txt').read()
+
+input = open("2020/input/day02.txt").read()
 passwords = [parse_line(x) for x in input.splitlines()]
 
+
 def validate_part_one(min, max, target, password):
     """
     Validate whether the given password contains the target character at least `min` times, and no more than `max`.
     """
     count = len([c for c in password if c == target])
     return count >= min and count <= max
 
+
 def validate_part_two(a, b, target, password):
     """
     Validate whether the given password contains the target character in position `a` or `b`, but not both.
     """
-    return (password[a-1] == target) ^ (password[b-1] == target)
+    return (password[a - 1] == target) ^ (password[b - 1] == target)
+
 
-print('part one: %d' % len([p for p in passwords if validate_part_one(*p)]))
-print('part two: %d' % len([p for p in passwords if validate_part_two(*p)]))
+print("part one: %d" % len([p for p in passwords if validate_part_one(*p)]))
+print("part two: %d" % len([p for p in passwords if validate_part_two(*p)]))

2020/python/aoc_2020/day03.py

@@ -1,7 +1,8 @@
 from functools import reduce
 from operator import mul
 
-input = open('2020/input/day03.txt').read().splitlines()
+input = open("2020/input/day03.txt").read().splitlines()
+
 
 def traverse(step_x, step_y):
     """
@@ -11,12 +12,18 @@ def traverse(step_x, step_y):
 
     while y < len(input):
         line = input[y]
-        if line[x % len(line)] == '#':
+        if line[x % len(line)] == "#":
             trees += 1
         x += step_x
         y += step_y
 
     return trees
 
-print('part one: %d' % traverse(3, 1))
-print('part two: %d' % reduce(mul, [traverse(*step) for step in [(1, 1), (3, 1), (5, 1), (7, 1), (1, 2)]]))
+
+print("part one: %d" % traverse(3, 1))
+print(
+    "part two: %d"
+    % reduce(
+        mul, [traverse(*step) for step in [(1, 1), (3, 1), (5, 1), (7, 1), (1, 2)]]
+    )
+)

2020/python/aoc_2020/day04.py

@@ -21,7 +21,7 @@ def __init__(self, fields: Dict[str, str]) -> None:
     @property
     def has_required_fields(self) -> bool:
         """Checks whether all required fields are present"""
-        required = ['byr', 'iyr', 'eyr', 'hgt', 'hcl', 'ecl', 'pid']
+        required = ["byr", "iyr", "eyr", "hgt", "hcl", "ecl", "pid"]
         for key in required:
             if key not in self.fields:
                 return False
@@ -31,67 +31,69 @@ def has_required_fields(self) -> bool:
     @property
     def has_valid_fields(self) -> bool:
         """Checks whether the required fields are valid according to the validation rules"""
-        return (self.has_required_fields and
-                self.has_valid_birth_year and
-                self.has_valid_issue_year and
-                self.has_valid_expiration_year and
-                self.has_valid_height and
-                self.has_valid_hair_color and
-                self.has_valid_eye_color and
-                self.has_valid_passport_id)
+        return (
+            self.has_required_fields
+            and self.has_valid_birth_year
+            and self.has_valid_issue_year
+            and self.has_valid_expiration_year
+            and self.has_valid_height
+            and self.has_valid_hair_color
+            and self.has_valid_eye_color
+            and self.has_valid_passport_id
+        )
 
     @property
     def has_valid_birth_year(self) -> bool:
         """Birth Year should be at least 1920 and at most 2002"""
-        return parse_int(self.fields['byr']) in range(1920, 2003)
+        return parse_int(self.fields["byr"]) in range(1920, 2003)
 
     @property
     def has_valid_issue_year(self) -> bool:
         """Issue Year should be at least 2010 and at most 2020"""
-        return parse_int(self.fields['iyr']) in range(2010, 2021)
+        return parse_int(self.fields["iyr"]) in range(2010, 2021)
 
     @property
     def has_valid_expiration_year(self) -> bool:
         """Expiration Year should be at least 2020 and at most 2030"""
-        return parse_int(self.fields['eyr']) in range(2020, 2031)
+        return parse_int(self.fields["eyr"]) in range(2020, 2031)
 
     @property
     def has_valid_height(self) -> bool:
         """Height should be at least 150cm and at most 193cm; or at least 59in and at most 76in"""
-        height = self.fields['hgt']
-        if height.endswith('cm'):
-            return parse_int(height.strip('cm')) in range(150, 194)
+        height = self.fields["hgt"]
+        if height.endswith("cm"):
+            return parse_int(height.strip("cm")) in range(150, 194)
 
-        if height.endswith('in'):
-            return parse_int(height.strip('in')) in range(59, 77)
+        if height.endswith("in"):
+            return parse_int(height.strip("in")) in range(59, 77)
 
         return False
 
     @property
     def has_valid_hair_color(self) -> bool:
         """Hair Color should contain a valid hexadecimal number"""
-        if re.match('^#[0-9a-f]{6}$', self.fields['hcl']):
+        if re.match("^#[0-9a-f]{6}$", self.fields["hcl"]):
             return True
         return False
 
     @property
     def has_valid_eye_color(self) -> bool:
         """Eye color should be one of the defined values"""
-        return self.fields['ecl'] in ['amb', 'blu', 'brn', 'gry', 'grn', 'hzl', 'oth']
+        return self.fields["ecl"] in ["amb", "blu", "brn", "gry", "grn", "hzl", "oth"]
 
     @property
     def has_valid_passport_id(self) -> bool:
         """Passport ID should be a nine-digit number, including leading zeroes"""
-        return len(self.fields['pid']) == 9 and self.fields['pid'].isdigit()
+        return len(self.fields["pid"]) == 9 and self.fields["pid"].isdigit()
 
 
 def parse_passport(data: str) -> Passport:
-    pairs = [pair.split(':') for pair in data.split()]
+    pairs = [pair.split(":") for pair in data.split()]
     fields = dict(pairs)
     return Passport(fields)
 
 
-with open('2020/input/day04.txt', encoding='utf8') as file:
+with open("2020/input/day04.txt", encoding="utf8") as file:
     passport_data = file.read().split(os.linesep + os.linesep)
     passports = [parse_passport(lines) for lines in passport_data]
 

2020/python/aoc_2020/day05.py

@@ -7,10 +7,10 @@ def find_row(seat: str, min_row: int = 0, max_row: int = 127) -> int:
     """Recursively finds the row of the given seat."""
     mid = max_row - int((max_row - min_row) / 2)
 
-    if seat.startswith('F'):
+    if seat.startswith("F"):
         return find_row(seat[1:], min_row=min_row, max_row=mid)
 
-    if seat.startswith('B'):
+    if seat.startswith("B"):
         return find_row(seat[1:], min_row=mid, max_row=max_row)
 
     return min_row
@@ -20,10 +20,10 @@ def find_column(seat: str, min_column: int = 0, max_column: int = 7) -> int:
     """Recursively finds the column of the given seat."""
     mid = max_column - int((max_column - min_column) / 2)
 
-    if seat.startswith('L'):
+    if seat.startswith("L"):
         return find_column(seat[1:], min_column=min_column, max_column=mid)
 
-    if seat.startswith('R'):
+    if seat.startswith("R"):
         return find_column(seat[1:], min_column=mid, max_column=max_column)
 
     return min_column
@@ -34,7 +34,7 @@ def find_seat_location(seat: str) -> Tuple[int, int]:
     return find_row(seat[:7]), find_column(seat[7:])
 
 
-with open('2020/input/day05.txt', encoding='utf8') as file:
+with open("2020/input/day05.txt", encoding="utf8") as file:
     seats = [find_seat_location(line) for line in file.read().splitlines()]
     seat_ids = [row * 8 + column for row, column in seats]
     max_seat = max(seat_ids)

2020/python/aoc_2020/day06.py

@@ -9,7 +9,7 @@ def union(group: List[List[str]]) -> List[str]:
     for answers in group:
         result = set(result) | set(answers)
 
-    return result
+    return list(result)
 
 
 def intersect(group: List[List[str]]) -> List[str]:
@@ -18,12 +18,13 @@ def intersect(group: List[List[str]]) -> List[str]:
     for answers in group:
         result = set(result) & set(answers)
 
-    return result
+    return list(result)
 
 
-with open('2020/input/day06.txt', encoding='utf8') as file:
-    groups = [group.splitlines()
-              for group in file.read().split(os.linesep + os.linesep)]
+with open("2020/input/day06.txt", encoding="utf8") as file:
+    groups = [
+        group.splitlines() for group in file.read().split(os.linesep + os.linesep)
+    ]
 
     print(f"part one: {sum(len(union(group)) for group in groups)}")
     print(f"part two: {sum(len(intersect(group)) for group in groups)}")