Final version

Author: jgrynczewski

.github/workflows/labs.yml

@@ -1,6 +1,6 @@
 # 👋 Intro - Prosty Kalkulator
 
-**Poziom**: bardzo łatwy  
+**Poziom**: N/A  
 **Cel**: Weryfikacja środowiska
 
 ## 🎯 Zadanie

0_intro/01_hello/README.md

@@ -0,0 +1,68 @@
+"""
+>>> add(2, 3)
+5
+
+>>> add(10, 5)
+15
+
+>>> multiply(2, 3)
+6
+
+>>> multiply(10, 5)
+50
+
+>>> add(0, 0)
+0
+
+>>> multiply(1, 1)
+1
+"""
+
+# %% About
+# - Name: Intro - Simple Calculator
+# - Difficulty: easy
+# - Lines: 4
+# - Focus: Setup verification
+
+# %% Description
+"""
+Intro Exercise: Simple Calculator
+
+Zaimplementuj dwie proste funkcje, żeby sprawdzić, że środowisko działa.
+"""
+
+# %% Hints
+# - Funkcja add() powinna zwrócić sumę dwóch liczb
+# - Funkcja multiply() powinna zwrócić iloczyn dwóch liczb
+
+# %% Run
+# - Terminal: `python -m doctest -f -v starter.py`
+# - Tests: `python -m pytest test_hello.py -v`
+
+
+def add(a, b):
+    """
+    Add two numbers.
+
+    Args:
+        a: First number
+        b: Second number
+
+    Returns:
+        Sum of a and b
+    """
+    return a + b
+
+
+def multiply(a, b):
+    """
+    Multiply two numbers.
+
+    Args:
+        a: First number
+        b: Second number
+
+    Returns:
+        Product of a and b
+    """
+    return a * b

0_intro/01_hello/solution.py

@@ -1,6 +1,6 @@
 # 🔗 GRASP Low Coupling - System Gry
 
-**Poziom**: łatwy
+**Poziom**: Łatwy  
 **Cel**: GRASP Low Coupling
 
 ## 🎯 Zadanie
@@ -44,12 +44,12 @@ class Game:
 ✅ **Dobrze** (luźne sprzężenie):
 ```python
 class Game:
-    def __init__(self, score_service):  # Pośrednik ✅
+    def __init__(self, score_service):  # 1. wstrzykujemy pośrednika ✅
         self.score_service = score_service
 
     def finish_game(self, player, score):
         self.score_service.save_score(player, score)
-        # Game nie zna Database - luźne sprzężenie
+        # 2. Game nie zna Database - luźne sprzężenie
 
 # ScoreService izoluje Game od Database
 ```

1_principles/01_grasp/04_low_coupling/README.md

@@ -0,0 +1,75 @@
+"""
+GRASP Low Coupling - Game System
+
+>>> # Test ScoreService
+>>> service = ScoreService()
+>>> service.save_score("player1", 100)
+'Saved score 100 for player1'
+
+>>> # Test Game with ScoreService (low coupling)
+>>> game = Game(service)
+>>> game.finish_game("Alice", 150)
+'Game finished. Saved score 150 for Alice'
+"""
+
+
+class Database:
+    """Konkretna implementacja bazy danych"""
+
+    def connect(self) -> str:
+        return "Connected to database"
+
+    def save(self, player: str, score: int) -> str:
+        return f"Saved score {score} for {player}"
+
+
+# TODO: Zaimplementuj ScoreService
+# Klasa pośrednicząca między Game a bazą danych (redukuje sprzężenie)
+# Metoda save_score(player, score) zwraca: "Saved score {score} for {player}"
+
+class ScoreService:
+    def __init__(self):
+        self.database = Database()
+
+    def save_score(self, player: str, score: int) -> str:
+        """Pośrednik - izoluje Game od Database"""
+        self.database.connect()
+        return self.database.save(player, score)
+
+
+# TODO: Zaimplementuj Game
+# Przyjmuje score_service: ScoreService w konstruktorze (dependency injection)
+# Metoda finish_game(player, score):
+#   - Wywołuje score_service.save_score(player, score)
+#   - Zwraca "Game finished. {wynik z save_score}"
+#
+# Low Coupling: Game nie zna Database, tylko ScoreService (pośrednik)
+
+class Game:
+    def __init__(self, score_service: ScoreService):
+        """Dependency Injection - redukuje sprzężenie"""
+        self.score_service = score_service
+
+    def finish_game(self, player: str, score: int) -> str:
+        """Game używa tylko ScoreService, nie zna Database"""
+        result = self.score_service.save_score(player, score)
+        return f"Game finished. {result}"
+
+
+# GRASP Low Coupling:
+# Minimalizuj zależności między klasami
+#
+# Silne sprzężenie ❌:
+# Game → Database (bezpośrednia zależność)
+#
+# Luźne sprzężenie ✅:
+# Game → ScoreService → Database (pośrednik)
+#
+# Korzyść: Zmiana Database nie wpływa na Game
+
+
+# Przykład użycia
+if __name__ == "__main__":
+    service = ScoreService()
+    game = Game(service)
+    print(game.finish_game("Alice", 150))

1_principles/01_grasp/04_low_coupling/solution.py

@@ -53,3 +53,10 @@ class Game:
 # Game → ScoreService → Database (pośrednik)
 #
 # Korzyść: Zmiana Database nie wpływa na Game
+
+
+# Przykład użycia - odkomentuj gdy zaimplementujesz:
+# if __name__ == "__main__":
+#     service = ScoreService()
+#     game = Game(service)
+#     print(game.finish_game("Alice", 150))

1_principles/01_grasp/04_low_coupling/starter.py

@@ -60,7 +60,7 @@ def finish_game(self, player: str, score: int) -> str:
     # Nie mogę - Game tworzy Database bezpośrednio w finish_game() (ew. patch)
     #
     # ❌ Chcę zmienić Database na inną implementację?
-    # Muszę EDYTOWAĆ Game.finish_game()
+    # Muszę EDYTOWAĆ Game().finish_game()
     #
     # ❌ Chcę dodać cache między Game a Database?
     # Muszę EDYTOWAĆ Game - nie ma miejsca na pośrednika
@@ -90,7 +90,7 @@ def finish_game(self, player: str, score: int) -> str:
    - Game odpowiada za komunikację z bazą
    - Dwie odpowiedzialności w jednej klasie
 
-5. ❌ Wysokie sprzężenie = niska "współużywalność"
+5. ❌ Silne sprzężenie = niska "współużywalność"
    - Game nie może działać bez Database
    - Nie można użyć Game z innym storage (file, API)
 
@@ -100,3 +100,9 @@ def finish_game(self, player: str, score: int) -> str:
 3. ScoreService izoluje Game od Database
 4. Game nie zna szczegółów Database - tylko wywołuje score_service.save_score()
 """
+
+
+# Przykład użycia
+if __name__ == "__main__":
+    game = Game()
+    print(game.finish_game("Alice", 150))

1_principles/01_grasp/04_low_coupling/violation.py

@@ -46,17 +46,28 @@ class AreaCalculator:
 
 ✅ **Dobrze** (rozszerzenie bez modyfikacji):
 ```python
-from abc import ABC
+from abc import ABC, abstractmethod
 
 class Shape(ABC):
-    ...
+    @abstractmethod
+    def calculate_area(self):
+        pass
 
 class Circle(Shape):
-    ...
+    def __init__(self, radius):
+        self.radius = radius
+
+    def calculate_area(self):
+        return 3.14 * self.radius ** 2
 
 # Nowy kształt = nowa klasa, zero zmian w AreaCalculator ✅
 class Rectangle(Shape):
-    ...
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+
+    def calculate_area(self):
+        return self.width * self.height
 ```
 
 **Korzyść**: `AreaCalculator` nie zmienia się przy dodaniu Rectangle.

1_principles/02_solid/02_ocp/README.md

@@ -0,0 +1,95 @@
+"""
+Open/Closed Principle - Shape Calculator
+
+>>> circle = Circle(5)
+>>> circle.calculate_area()
+78.5
+
+>>> square = Square(4)
+>>> square.calculate_area()
+16
+
+>>> triangle = Triangle(3, 4)
+>>> triangle.calculate_area()
+6.0
+
+>>> # Test AreaCalculator
+>>> shapes = [Circle(5), Square(4), Triangle(3, 4)]
+>>> calculator = AreaCalculator()
+>>> total = calculator.total_area(shapes)
+>>> total
+100.5
+"""
+
+from abc import ABC, abstractmethod
+
+
+# TODO: Zaimplementuj interfejs Shape
+# Klasa abstrakcyjna z metodą calculate_area()
+
+class Shape(ABC):
+    @abstractmethod
+    def calculate_area(self):
+        """Metoda abstrakcyjna - każdy kształt musi ją zaimplementować"""
+        pass
+
+
+# TODO: Zaimplementuj Circle
+# Przyjmuje radius w konstruktorze
+# Dziedziczy po Shape
+# Pole = π * r²  (użyj 3.14 dla π)
+
+class Circle(Shape):
+    def __init__(self, radius: float):
+        self.radius = radius
+
+    def calculate_area(self) -> float:
+        return 3.14 * self.radius ** 2
+
+
+# TODO: Zaimplementuj Square
+# Przyjmuje side w konstruktorze
+# Dziedziczy po Shape
+# Pole = side²
+
+class Square(Shape):
+    def __init__(self, side: float):
+        self.side = side
+
+    def calculate_area(self) -> float:
+        return self.side ** 2
+
+
+# TODO: Zaimplementuj Triangle
+# Przyjmuje base i height w konstruktorze
+# Dziedziczy po Shape
+# Pole = (base * height) / 2
+
+class Triangle(Shape):
+    def __init__(self, base: float, height: float):
+        self.base = base
+        self.height = height
+
+    def calculate_area(self) -> float:
+        return (self.base * self.height) / 2
+
+
+# TODO: Zaimplementuj AreaCalculator
+# Metoda total_area(shapes) przyjmuje listę kształtów
+# i zwraca sumę ich pól używając polimorfizmu
+
+class AreaCalculator:
+    def total_area(self, shapes: list) -> float:
+        """Polimorfizm - każdy kształt wie jak obliczyć swoje pole"""
+        return sum(shape.calculate_area() for shape in shapes)
+
+
+# OCP: Open for extension, Closed for modification
+# Nowy kształt = nowa klasa Shape, zero zmian w AreaCalculator
+
+
+# Przykład użycia
+if __name__ == "__main__":
+    shapes = [Circle(5), Square(4), Triangle(3, 4)]
+    calculator = AreaCalculator()
+    print(f"Total area: {calculator.total_area(shapes)}")

1_principles/02_solid/02_ocp/solution.py

@@ -66,3 +66,10 @@ class AreaCalculator:
 
 # OCP: Open for extension, Closed for modification
 # Nowy kształt = nowa klasa Shape, zero zmian w AreaCalculator
+
+
+# Przykład użycia - odkomentuj gdy zaimplementujesz:
+# if __name__ == "__main__":
+#     shapes = [Circle(5), Square(4), Triangle(3, 4)]
+#     calculator = AreaCalculator()
+#     print(f"Total area: {calculator.total_area(shapes)}")