labs

Week03/pyramid_vladyslav_senkiv.py

@@ -0,0 +1,10 @@
+def calculate_pyramid_height(number_of_blocks):
+    height = 0
+    i = 1
+
+    while number_of_blocks >= i:
+        number_of_blocks = number_of_blocks - i
+        height += 1
+        i += 1
+
+    return height

Week03/sequences_vladyslav_senkiv.py

@@ -0,0 +1,17 @@
+def remove_duplicates(seq: list) -> list:
+    result = []
+    for item in seq:
+        if item not in result:
+            result.append(item)
+    return result
+
+
+def list_counts(seq: list) -> dict:
+    counts = {}
+    for item in seq:
+        counts[item] = counts.get(item, 0) + 1
+    return counts
+
+
+def reverse_dict(d: dict) -> dict:
+    return {value: key for key, value in d.items()}

Week04/decorators_vladyslav_senkiv.py

@@ -0,0 +1,28 @@
+from functools import wraps
+from time import perf_counter
+import tracemalloc
+
+
+
+def performance(func):
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        wrapper.counter += 1
+
+        tracemalloc.start()
+        start = perf_counter()
+        try:
+            return func(*args, **kwargs)
+        finally:
+            elapsed = perf_counter() - start
+            current, peak = tracemalloc.get_traced_memory()
+            tracemalloc.stop()
+
+            wrapper.total_time += elapsed
+            wrapper.total_mem += peak
+
+    wrapper.counter = 0
+    wrapper.total_time = 0.0
+    wrapper.total_mem = 0
+    return wrapper

Week04/functions_vladyslav_senkiv.py

@@ -0,0 +1,41 @@
+import inspect
+from typing import Dict, Tuple
+
+
+custom_power = lambda x=0, /, e=1: x**e
+
+
+def custom_equation(
+    x: int = 0,
+    y: int = 0,
+    /,
+    a: int = 1,
+    b: int = 1,
+    *,
+    c: int = 1,
+) -> float:
+    """Calculate a custom equation.
+
+    :param x: First base value.
+    :param y: Second base value.
+    :param a: Exponent for x.
+    :param b: Exponent for y.
+    :param c: Divisor value.
+    :returns: The result of (x**a + y**b) / c.
+    """
+    return float((x**a + y**b) / c)
+
+
+def fn_w_counter() -> (int, dict[str, int]):
+    """Count total calls and calls grouped by caller module name."""
+    if not hasattr(fn_w_counter, "total_calls"):
+        fn_w_counter.total_calls = 0
+        fn_w_counter.caller_counts = {}
+
+    caller_frame = inspect.currentframe().f_back
+    caller_name = caller_frame.f_globals.get("__name__", "__main__")
+
+    fn_w_counter.total_calls += 1
+    fn_w_counter.caller_counts[caller_name] = fn_w_counter.caller_counts.get(caller_name, 0) + 1
+
+    return fn_w_counter.total_calls, dict(fn_w_counter.caller_counts)

Week05/awaitme_vladyslav_senkiv.py

@@ -0,0 +1,14 @@
+import inspect
+from functools import wraps
+
+
+
+def awaitme(func):
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        result = func(*args, **kwargs)
+        if inspect.isawaitable(result):
+            return await result
+        return result
+
+    return wrapper

Week06/timer_vladyslav_senkiv.py

@@ -0,0 +1,15 @@
+from time import perf_counter
+
+class Timer:
+
+    def __init__(self):
+        self.start_time = None
+        self.end_time = None
+
+    def __enter__(self):
+        self.start_time = perf_counter()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.end_time = perf_counter()
+        return False