fix: changed return annotation to test requirements

Author: FurkanCetinerr

Week04/decorators_furkan_cetiner.py

@@ -1,34 +1,52 @@
+from __future__ import annotations
+
 import time
 import tracemalloc
-import functools
-
-def performance(func):
-    """
-    Fonksiyonun performansını ölçen ve istatistiklerini saklayan dekoratör.
-    """
-    if not hasattr(performance, "counter"):
-        performance.counter = 0
-        performance.total_time = 0.0
-        performance.total_mem = 0
-
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        tracemalloc.start()
-        start_time = time.perf_counter()
-        result = func(*args, **kwargs)
-        end_time = time.perf_counter()
-
-        current_mem, peak_mem = tracemalloc.get_traced_memory()
-        tracemalloc.stop()
-
-        performance.counter += 1
-        performance.total_time += (end_time - start_time)
-        performance.total_mem += peak_mem
+from functools import wraps
+from typing import Any, Callable, TypeVar, cast
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def performance(func: F) -> F:
+
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        # ensure stats exist
+        wrapper.counter += 1  # type: ignore[attr-defined]
+
+        # time
+        t0 = time.perf_counter()
+
+        # memory (tracemalloc)
+        tracing_already = tracemalloc.is_tracing()
+        if not tracing_already:
+            tracemalloc.start()
+
+        before_current, before_peak = tracemalloc.get_traced_memory()
+        try:
+            result = func(*args, **kwargs)
+        finally:
+            after_current, after_peak = tracemalloc.get_traced_memory()
+            dt = time.perf_counter() - t0
+
+            wrapper.total_time += dt  # type: ignore[attr-defined]
+
+            # Use peak delta as "consumed" approximation for this call
+            delta_peak = after_peak - before_peak
+            if delta_peak < 0:
+                delta_peak = 0
+            wrapper.total_mem += int(delta_peak)  # type: ignore[attr-defined]
+
+            # Don't disrupt global tracing if it was already enabled
+            if not tracing_already:
+                tracemalloc.stop()
 
         return result
 
-    return wrapper
+    # required attributes
+    wrapper.counter = 0       # type: ignore[attr-defined]
+    wrapper.total_time = 0.0  # type: ignore[attr-defined]
+    wrapper.total_mem = 0     # type: ignore[attr-defined]
 
-performance.counter = 0
-performance.total_time = 0.0
-performance.total_mem = 0
+    return cast(F, wrapper)

Week04/functions_furkan_cetiner.py

@@ -1,34 +1,36 @@
+from __future__ import annotations
+
 import inspect
+from typing import Any, Dict, Tuple
+
 
-# 1. custom_power: lambda function with positional-only x
 custom_power = lambda x=0, /, e=1: x**e
 
-# 2. custom_equation: positional-only, positional-or-keyword, and keyword-only params
+
 def custom_equation(x: int = 0, y: int = 0, /, a: int = 1, b: int = 1, *, c: int = 1) -> float:
-    """
-    Calculates (x**a + y**b) / c with specific parameter constraints.
-    :param x: Base 1, positional-only
-    :param y: Base 2, positional-only
-    :param a: Exponent 1, positional-or-keyword
-    :param b: Exponent 2, positional-or-keyword
-    :param c: Divisor, keyword-only
-    :returns: Result as float
-    """
-    return float((x**a + y**b) / c)
-
-# 3. fn_w_counter: tracks total calls and caller names
-def fn_w_counter() -> (int, dict[str, int]):
-    """
-    Counts the number of calls and tracks the caller (__name__).
-    """
-    if not hasattr(fn_w_counter, "calls"):
-        fn_w_counter.calls = 0
-        fn_w_counter.callers = {}
-
-    caller_frame = inspect.currentframe().f_back
-    caller_name = caller_frame.f_globals.get('__name__', 'unknown')
-
-    fn_w_counter.calls += 1
-    fn_w_counter.callers[caller_name] = fn_w_counter.callers.get(caller_name, 0) + 1
-
-    return (fn_w_counter.calls, fn_w_counter.callers)
+
+    return (x**a + y**b) / c
+
+
+def fn_w_counter() -> Tuple[int, Dict[str, int]]:
+
+
+    if not hasattr(fn_w_counter, "_total"):
+        fn_w_counter._total = 0  # type: ignore[attr-defined]
+    if not hasattr(fn_w_counter, "_by_caller"):
+        fn_w_counter._by_caller = {}  # type: ignore[attr-defined]
+
+
+    frame = inspect.currentframe()
+    caller_frame = frame.f_back if frame is not None else None
+    caller_name = "<unknown>"
+    if caller_frame is not None:
+        caller_name = str(caller_frame.f_globals.get("__name__", "<unknown>"))
+
+
+    fn_w_counter._total += 1  # type: ignore[attr-defined]
+    by_caller: Dict[str, int] = fn_w_counter._by_caller  # type: ignore[attr-defined]
+    by_caller[caller_name] = by_caller.get(caller_name, 0) + 1
+
+
+    return int(fn_w_counter._total), dict(by_caller)  # type: ignore[attr-defined]