refactor: move some classes and functions to separate files

.gitignore

@@ -0,0 +1,2 @@
+.vscode
+__pycache__

pyproject.toml

@@ -4,4 +4,7 @@ version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.14"
-dependencies = []
+dependencies = [
+    "icecream>=2.2.0",
+    "numpy>=2.4.2",
+]

task2/command_translation.py

@@ -0,0 +1,50 @@
+from collections import deque
+from typing import Iterable
+from icecream import ic
+
+from math_objects import Operator, Parenthesis, Token
+
+__left_parenthesis_error = "__left_parenthesis_error"
+__right_parenthesis_error = "__right_parenthesis_error"
+__empty_parentheses_error = "__empty_parentheses_error"
+
+
+def translate(tokens: Iterable[Token]) -> Iterable[Token]:
+    operator_stack: deque[Operator] = deque()
+    previous_stacks: deque[deque[Operator]] = deque()
+    previous_precedence = 0
+    empty_stack = True
+
+    for token in tokens:
+        if isinstance(token, Parenthesis):
+            match token.value:
+                case "(":
+                    previous_stacks.append(operator_stack)
+                    operator_stack = deque()
+                    empty_stack = True
+                case _:
+                    if empty_stack:
+                        raise SystemError(__empty_parentheses_error)
+                    if operator_stack:
+                        for item in reversed(operator_stack):
+                            yield item
+                    try:
+                        operator_stack = previous_stacks.pop()
+                    except IndexError:
+                        raise SyntaxError(__right_parenthesis_error)
+            continue
+        empty_stack = False
+        if not isinstance(token, Operator):
+            yield token
+            continue
+        if token.precedence <= previous_precedence:
+            for item in reversed(operator_stack):
+                yield item
+            operator_stack.clear()
+        previous_precedence = token.precedence
+        operator_stack.append(token)
+    if previous_stacks:
+        raise SyntaxError(__left_parenthesis_error)
+    if operator_stack:
+        for item in reversed(operator_stack):
+            yield item

task2/main.py

@@ -0,0 +1,32 @@
+from collections import deque
+from icecream import ic
+from typing import Iterable
+
+from command_translation import translate
+from tokenizer import tokenize
+
+from math_objects import Token, Integer, Operator
+
+equation: str = input()
+
+if not equation.strip():
+    raise SyntaxError("Пустая строка")
+
+tokens: Iterable[Token] = tokenize(equation)
+sorted_tokens: Iterable[Token] = translate(tokens)
+
+token_stack: deque[Token] = deque()
+
+for token in sorted_tokens:
+    if not isinstance(token, Operator):
+        token_stack.append(token)
+        continue
+    try:
+        b, a = token_stack.pop(), token_stack.pop()
+    except IndexError:
+        raise SyntaxError
+    ic(a.value, token.value, b.value)
+    new_integer = Integer(eval(f"{a.value}{token.value}{b.value}"))
+    token_stack.append(new_integer)
+
+print(token_stack.pop().value)

task2/math_objects.py

@@ -0,0 +1,29 @@
+from collections import deque
+from typing import Literal, Self
+
+
+class Token[T]:
+    value: T
+
+    def __init__(self, value: T) -> None:
+        self.value = value
+
+class Integer(Token[int]):
+    @classmethod
+    def create_from_string(cls, string: str) -> Self:
+        return cls(int(string))
+
+type _OperatorType = Literal["+", "-", "*", "/"]
+
+class Operator(Token[_OperatorType]):
+    def __init__(self, value: Literal["+", "-", "*", "/"], precedence = 0) -> None:
+        super().__init__(value)
+        self.precedence: int = precedence
+
+type _Parentheses = Literal["(", ")"]
+
+class Parenthesis(Token[_Parentheses]):
+    pass
+
+# class Stack(MathObject[deque[MathObject]]):
+#     pass

task2/tokenizer.py

@@ -0,0 +1,33 @@
+from collections import deque
+from typing import Iterable, Literal, Optional
+
+from math_objects import Integer, Operator, Parenthesis, Token
+
+
+def tokenize(string: str) -> Iterable[Token]:
+    buffer: deque[str] = deque()
+
+    def _take_buffer() -> str:
+        string = "".join(buffer)
+        buffer.clear()
+        return string
+
+    for c in string:
+        if c.isdigit():
+            buffer.append(c)
+        elif c in ["+", "-", "*", "/", "(", ")"]:
+            if buffer:
+                yield Integer.create_from_string(_take_buffer())
+            match c:
+                case "+" | "-":
+                    yield Operator(c, precedence=1)
+                case "*" | "/":
+                    yield Operator(c, precedence=2)
+                case _:
+                    yield Parenthesis(c) # type: ignore
+        elif c == " ":
+            pass
+        else:
+            raise SyntaxError(f"Недопустимый символ: {c}")
+    if buffer:
+        yield Integer.create_from_string(_take_buffer())

task6/entities.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass
+class Request:
+    request_time: int
+    plane: Plane
+
+@dataclass
+class ProcessedRequest(Request):
+    start_process_time: int
+    process_time: int
+    type_: Literal["landing", "launching"]
+
+class Plane:
+    __id_increment = 0
+
+    def __init__(self) -> None:
+        self.id = self.__id_increment
+        Plane.__id_increment += 1

task6/main.py

@@ -0,0 +1,100 @@
+from stats import Stats, finalize_waiting_stats, show_stats
+from entities import Plane, ProcessedRequest, Request
+from queues import EnforcingQueue, PermissiveQueue, Queue
+
+from numpy import random
+from typing import Final, Iterable, Optional
+
+from numpy.typing import NDArray
+
+
+def warn_about_outcoming_queue_overload(queue: Queue) -> None:
+    print(f"Outcoming queue is overloaded: {len(queue)} planes/{queue.size} planes")
+
+def reject_plane(plane: Plane) -> None:
+    stats.rejected_in_requests += 1
+    print(f"Rejected incoming plane №{plane.id}")
+
+def launch_plane(plane: Plane, stats: Stats) -> None:
+    stats.launches_count += 1
+    print(f"Launched plane №{plane.id}")
+
+def land_plane(plane: Plane, stats: Stats) -> None:
+    stats.landings_count += 1
+    print(f"Plane №{plane.id} landed")
+
+def generate_timeline(incoming_planes_per_hour: float, outcoming_planes_per_hour: float, interval_minutes: int) -> Iterable[tuple[int, int]]:
+    def _generate(planes_per_hour: float) -> NDArray:
+        return random.poisson(planes_per_hour / 60, interval_minutes)
+
+    incoming_planes_per_minute = _generate(incoming_planes_per_hour)
+    outcoming_planes_per_minute = _generate(outcoming_planes_per_hour)
+    return zip(incoming_planes_per_minute, outcoming_planes_per_minute)
+
+def process_new_request(in_queue: Queue[Request], out_queue: Queue[Request], current_time: int, process_duration: int) -> ProcessedRequest:
+    plane: Optional[Plane]
+    if in_queue:
+        request = in_queue.pop()
+        plane = request.plane
+        stats.in_waiting_time.append(current_time - request.request_time)
+        print(f"{current_time}: Processing incoming plane №{plane.id}")
+        process_type = "landing"
+    else:
+        request = out_queue.pop()
+        plane = request.plane
+        stats.out_waiting_time.append(current_time - request.request_time)
+        print(f"{current_time}: Processing outcoming plane №{plane.id}")
+        process_type = "launching"
+    return ProcessedRequest(request.request_time, request.plane, current_time, current_time + process_duration, process_type)
+
+takeoff_duration: Final[int] = int(input("Takeoff duration: ")) # minutes
+
+max_queue: Final[int] = int(input("Max queue: "))
+interval: Final[int] = int(input("Interval: ")) # minutes
+incoming_planes, outcoming_planes = map(float, input("Planes: ").split()) # per hour
+
+in_queue: Queue[Request] = EnforcingQueue[Request](max_queue)
+out_queue: Queue[Request] = PermissiveQueue[Request](max_queue, warn_about_outcoming_queue_overload)
+
+current_request: Optional[ProcessedRequest] = None
+
+stats = Stats()
+timeline = generate_timeline(5,2, interval)
+
+i = 0
+
+for i, (in_planes_count, out_planes_count) in enumerate(timeline):
+    stats.total_plane_requests += in_planes_count + out_planes_count
+    stats.in_requests += in_planes_count
+    stats.out_requests += out_planes_count
+
+    for _ in range(in_planes_count):
+        new_plane = Plane()
+        try:
+            in_queue.add(Request(i, new_plane))
+            stats.accepted_in_requests += 1
+        except IndexError:
+            reject_plane(new_plane)
+            stats.rejected_in_requests += 1
+    for _ in range(out_planes_count):
+        new_plane = Plane()
+        out_queue.add(Request(i, new_plane))
+        stats.accepted_out_requests += 1
+    
+    if not current_request:
+        if len(in_queue) or len(out_queue):
+            current_request = process_new_request(in_queue, out_queue, i, takeoff_duration)
+            continue
+        stats.sleep_minutes += 1
+    if current_request and current_request.process_time == i:
+        if current_request.type_ == "launching":
+            launch_plane(current_request.plane, stats)
+        else:
+            land_plane(current_request.plane, stats)
+        current_request = None
+
+stats.in_queued = len(in_queue)
+stats.out_queued = len(out_queue)
+
+finalize_waiting_stats(stats, in_queue, out_queue, i)
+show_stats(stats)

task6/queues.py

@@ -0,0 +1,50 @@
+from abc import ABC, abstractmethod
+from collections import deque
+from typing import Callable, Optional, Self, override
+
+
+class Queue[T](ABC):
+    def __init__(self, size: int) -> None:
+        self.size = size
+        self.queue: deque[T] = deque()
+    
+    def __len__(self) -> int:
+        return len(self.queue)
+
+    def __bool__(self) -> bool:
+        return bool(self.queue)
+
+    @abstractmethod
+    def add(self, item: T) -> None: pass
+
+    @abstractmethod
+    def pop(self) -> T: pass
+
+class PermissiveQueue[T](Queue):
+    def __init__(self, size: int, overload_function: Optional[Callable[[Self], None]] = None) -> None:
+        super().__init__(size)
+        self._on_overload = overload_function
+
+    @override
+    def add(self, item: T) -> None:
+        self.queue.append(item)
+        if self._on_overload and len(self.queue) > self.size:
+            self._on_overload(self)
+    
+    @override
+    def pop(self) -> T:
+        return self.queue.popleft()
+
+class EnforcingQueue[T](Queue):
+    def __init__(self, size: int) -> None:
+        super().__init__(size)
+
+    @override
+    def add(self, item: T) -> None:
+        if len(self.queue) >= self.size:
+            raise IndexError
+        self.queue.append(item)
+    
+    @override
+    def pop(self) -> T:
+        return self.queue.popleft()

task6/stats.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass, field
+
+from numpy import average
+
+from entities import Request
+from queues import Queue
+
+
+@dataclass
+class Stats:
+    total_plane_requests = 0
+
+    in_requests = 0
+    out_requests = 0
+
+    accepted_in_requests = 0
+    accepted_out_requests = 0
+
+    rejected_in_requests = 0
+    rejected_out_requests = 0
+
+    landings_count = 0
+    launches_count = 0
+
+    in_queued = 0
+    out_queued = 0
+
+    sleep_minutes = 0
+
+    in_waiting_time: list[float] = field(default_factory=list)
+    out_waiting_time: list[float] = field(default_factory=list)
+
+def show_stats(stats: Stats) -> None:
+    string = f"""============
+Total requests: {stats.total_plane_requests}
+In requests: {stats.in_requests}
+Out requests: {stats.out_requests}
+Accepted in requests: {stats.accepted_in_requests}
+Accepted out requests: {stats.accepted_out_requests}
+Rejected in/out: {stats.rejected_in_requests}/{stats.rejected_out_requests}
+Landings: {stats.landings_count}
+Launches: {stats.launches_count}
+Left in queues (in/out): {stats.in_queued}/{stats.out_queued}
+Sleep: {stats.sleep_minutes}
+Average waiting time (in/out): {average(stats.in_waiting_time)}/{average(stats.out_waiting_time)}
+"""
+    print(string)
+
+def finalize_waiting_stats(stats: Stats, in_queue: Queue[Request], out_queue: Queue[Request], current_time: int) -> None:
+    for item in in_queue.queue:
+        stats.in_waiting_time.append(current_time - item.request_time)
+    for item in out_queue.queue:
+        stats.out_waiting_time.append(current_time - item.request_time)

task7/main.py

@@ -0,0 +1,40 @@
+from itertools import combinations, repeat
+import random
+from typing import Any, Final, Iterable
+from collections import Counter
+
+from icecream import ic
+
+
+sets_count: Final[int] = random.randint(2, 1000)
+elements_count: Final[Iterable[int]] = (random.randint(3, 10000) for _ in repeat(None, sets_count))
+
+ic(sets_count)
+
+sets: list[set[int]] = [
+    set(
+        random.sample(range(-2_000_000_000, 2_000_000_000 + 1), count)
+    )
+    for count in elements_count
+]
+
+elements_to_sets: dict[int, list[int]] = {}
+pair_counts: Counter[tuple[int, int]] = Counter()
+
+for i, set_ in enumerate(sets):
+    for element in set_:
+        elements_to_sets.setdefault(element, list()).append(i)
+
+ic(len(elements_to_sets))
+
+for sets_ in filter(lambda x: len(x) > 1, elements_to_sets.values()):
+    pair_counts.update(combinations(sets_, 2))
+
+sets_with_most_intersections: list[tuple[Any, int]] = pair_counts.most_common(1)
+
+if sets_with_most_intersections:
+    max_intersection: int = sets_with_most_intersections[0][1]
+else:
+    max_intersection = 0
+
+print(max_intersection)

task7/naive_approach.py

@@ -0,0 +1,36 @@
+from itertools import repeat
+import random
+from typing import Final, Iterable
+
+from icecream import ic
+
+
+sets_count: Final[int] = random.randint(2, 1000)
+elements_count: Final[Iterable[int]] = (random.randint(3, 10000) for _ in repeat(None, sets_count))
+
+ic(sets_count)
+
+sets: list[set[int]] = [
+    set(
+        random.sample(range(-2_000_000_000, 2_000_000_000 + 1), count)
+    )
+    for count in elements_count
+]
+sets.sort(key=lambda x: len(x), reverse=True)
+ic(list(map(len, sets)))
+
+max_intersection = 0
+
+for i in range(len(sets) - 1):
+    if max_intersection >= len(sets[i]):
+        ic(f"break on {i}")
+        break
+    for j in range(i + 1, len(sets)):
+        if max_intersection > len(sets[j]):
+            ic(f"break on {i};{j}")
+            break
+        if (intersection := len(sets[i].intersection(sets[j]))) > max_intersection:
+            max_intersection = intersection
+            ic(max_intersection)
+
+print(max_intersection)

task8/main.py

@@ -0,0 +1,27 @@
+from collections import Counter
+
+from icecream import ic
+
+
+string: str = input()
+max_weight = 0
+
+def calculate_weight(counter: Counter[str], length: int) -> int:
+    max_occurence: int = counter.most_common(1)[0][1]
+    return max_occurence * length
+
+counter: Counter[str] = Counter()
+
+for length in range(1, len(string) + 1):
+    counter.clear()
+    counter.update(
+        string[i:i+length] for i in range(len(string) - length + 1)
+    )
+    # ic(counter)
+    max_weight: int = max(
+        max_weight,
+        calculate_weight(counter, length)
+    )
+    ic(max_weight)
+
+print(max_weight)

uv.lock

@@ -0,0 +1,98 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"
+
+[[package]]
+name = "algorithms"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "icecream" },
+    { name = "numpy" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "icecream", specifier = ">=2.2.0" },
+    { name = "numpy", specifier = ">=2.4.2" },
+]
+
+[[package]]
+name = "asttokens"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "executing"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" },
+]
+
+[[package]]
+name = "icecream"
+version = "2.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "asttokens" },
+    { name = "colorama" },
+    { name = "executing" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/10/84/6ebc95844feae8a6a29c7fd57e9e3a7ac4817ffab384dc4f0ed53b8e3c46/icecream-2.2.0.tar.gz", hash = "sha256:9d7f244187f00a13f4ac77d176990e187e9c279d6cac4f7548e338291ad97343", size = 14267, upload-time = "2026-04-03T17:42:51.387Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/82/9707c7b0336bca53b75f52fc350956a93da66eb6be632b370bc933216fb4/icecream-2.2.0-py3-none-any.whl", hash = "sha256:f8df7343b3e787023eec22f42fbe4722df2f93099d394fd820b91e16b2e6cb56", size = 16707, upload-time = "2026-04-03T17:42:50.001Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/fd/0005efbd0af48e55eb3c7208af93f2862d4b1a56cd78e84309a2d959208d/numpy-2.4.2.tar.gz", hash = "sha256:659a6107e31a83c4e33f763942275fd278b21d095094044eb35569e86a21ddae", size = 20723651, upload-time = "2026-01-31T23:13:10.135Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/88/b7df6050bf18fdcfb7046286c6535cabbdd2064a3440fca3f069d319c16e/numpy-2.4.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:444be170853f1f9d528428eceb55f12918e4fda5d8805480f36a002f1415e09b", size = 16663092, upload-time = "2026-01-31T23:12:04.521Z" },
+    { url = "https://files.pythonhosted.org/packages/25/7a/1fee4329abc705a469a4afe6e69b1ef7e915117747886327104a8493a955/numpy-2.4.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d1240d50adff70c2a88217698ca844723068533f3f5c5fa6ee2e3220e3bdb000", size = 14698770, upload-time = "2026-01-31T23:12:06.96Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/0b/f9e49ba6c923678ad5bc38181c08ac5e53b7a5754dbca8e581aa1a56b1ff/numpy-2.4.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:7cdde6de52fb6664b00b056341265441192d1291c130e99183ec0d4b110ff8b1", size = 5208562, upload-time = "2026-01-31T23:12:09.632Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/12/d7de8f6f53f9bb76997e5e4c069eda2051e3fe134e9181671c4391677bb2/numpy-2.4.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:cda077c2e5b780200b6b3e09d0b42205a3d1c68f30c6dceb90401c13bff8fe74", size = 6543710, upload-time = "2026-01-31T23:12:11.969Z" },
+    { url = "https://files.pythonhosted.org/packages/09/63/c66418c2e0268a31a4cf8a8b512685748200f8e8e8ec6c507ce14e773529/numpy-2.4.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d30291931c915b2ab5717c2974bb95ee891a1cf22ebc16a8006bd59cd210d40a", size = 15677205, upload-time = "2026-01-31T23:12:14.33Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6c/7f237821c9642fb2a04d2f1e88b4295677144ca93285fd76eff3bcba858d/numpy-2.4.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bba37bc29d4d85761deed3954a1bc62be7cf462b9510b51d367b769a8c8df325", size = 16611738, upload-time = "2026-01-31T23:12:16.525Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/a7/39c4cdda9f019b609b5c473899d87abff092fc908cfe4d1ecb2fcff453b0/numpy-2.4.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b2f0073ed0868db1dcd86e052d37279eef185b9c8db5bf61f30f46adac63c909", size = 17028888, upload-time = "2026-01-31T23:12:19.306Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b3/e84bb64bdfea967cc10950d71090ec2d84b49bc691df0025dddb7c26e8e3/numpy-2.4.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7f54844851cdb630ceb623dcec4db3240d1ac13d4990532446761baede94996a", size = 18339556, upload-time = "2026-01-31T23:12:21.816Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f5/954a291bc1192a27081706862ac62bb5920fbecfbaa302f64682aa90beed/numpy-2.4.2-cp314-cp314-win32.whl", hash = "sha256:12e26134a0331d8dbd9351620f037ec470b7c75929cb8a1537f6bfe411152a1a", size = 6006899, upload-time = "2026-01-31T23:12:24.14Z" },
+    { url = "https://files.pythonhosted.org/packages/05/cb/eff72a91b2efdd1bc98b3b8759f6a1654aa87612fc86e3d87d6fe4f948c4/numpy-2.4.2-cp314-cp314-win_amd64.whl", hash = "sha256:068cdb2d0d644cdb45670810894f6a0600797a69c05f1ac478e8d31670b8ee75", size = 12443072, upload-time = "2026-01-31T23:12:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/37/75/62726948db36a56428fce4ba80a115716dc4fad6a3a4352487f8bb950966/numpy-2.4.2-cp314-cp314-win_arm64.whl", hash = "sha256:6ed0be1ee58eef41231a5c943d7d1375f093142702d5723ca2eb07db9b934b05", size = 10494886, upload-time = "2026-01-31T23:12:28.488Z" },
+    { url = "https://files.pythonhosted.org/packages/36/2f/ee93744f1e0661dc267e4b21940870cabfae187c092e1433b77b09b50ac4/numpy-2.4.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:98f16a80e917003a12c0580f97b5f875853ebc33e2eaa4bccfc8201ac6869308", size = 14818567, upload-time = "2026-01-31T23:12:30.709Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/24/6535212add7d76ff938d8bdc654f53f88d35cddedf807a599e180dcb8e66/numpy-2.4.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:20abd069b9cda45874498b245c8015b18ace6de8546bf50dfa8cea1696ed06ef", size = 5328372, upload-time = "2026-01-31T23:12:32.962Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/9d/c48f0a035725f925634bf6b8994253b43f2047f6778a54147d7e213bc5a7/numpy-2.4.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:e98c97502435b53741540a5717a6749ac2ada901056c7db951d33e11c885cc7d", size = 6649306, upload-time = "2026-01-31T23:12:34.797Z" },
+    { url = "https://files.pythonhosted.org/packages/81/05/7c73a9574cd4a53a25907bad38b59ac83919c0ddc8234ec157f344d57d9a/numpy-2.4.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da6cad4e82cb893db4b69105c604d805e0c3ce11501a55b5e9f9083b47d2ffe8", size = 15722394, upload-time = "2026-01-31T23:12:36.565Z" },
+    { url = "https://files.pythonhosted.org/packages/35/fa/4de10089f21fc7d18442c4a767ab156b25c2a6eaf187c0db6d9ecdaeb43f/numpy-2.4.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e4424677ce4b47fe73c8b5556d876571f7c6945d264201180db2dc34f676ab5", size = 16653343, upload-time = "2026-01-31T23:12:39.188Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/f9/d33e4ffc857f3763a57aa85650f2e82486832d7492280ac21ba9efda80da/numpy-2.4.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2b8f157c8a6f20eb657e240f8985cc135598b2b46985c5bccbde7616dc9c6b1e", size = 17078045, upload-time = "2026-01-31T23:12:42.041Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b8/54bdb43b6225badbea6389fa038c4ef868c44f5890f95dd530a218706da3/numpy-2.4.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5daf6f3914a733336dab21a05cdec343144600e964d2fcdabaac0c0269874b2a", size = 18380024, upload-time = "2026-01-31T23:12:44.331Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/55/6e1a61ded7af8df04016d81b5b02daa59f2ea9252ee0397cb9f631efe9e5/numpy-2.4.2-cp314-cp314t-win32.whl", hash = "sha256:8c50dd1fc8826f5b26a5ee4d77ca55d88a895f4e4819c7ecc2a9f5905047a443", size = 6153937, upload-time = "2026-01-31T23:12:47.229Z" },
+    { url = "https://files.pythonhosted.org/packages/45/aa/fa6118d1ed6d776b0983f3ceac9b1a5558e80df9365b1c3aa6d42bf9eee4/numpy-2.4.2-cp314-cp314t-win_amd64.whl", hash = "sha256:fcf92bee92742edd401ba41135185866f7026c502617f422eb432cfeca4fe236", size = 12631844, upload-time = "2026-01-31T23:12:48.997Z" },
+    { url = "https://files.pythonhosted.org/packages/32/0a/2ec5deea6dcd158f254a7b372fb09cfba5719419c8d66343bab35237b3fb/numpy-2.4.2-cp314-cp314t-win_arm64.whl", hash = "sha256:1f92f53998a17265194018d1cc321b2e96e900ca52d54c7c77837b71b9465181", size = 10565379, upload-time = "2026-01-31T23:12:51.345Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]