Encapsulation —
Hiding Complexity,
Revealing Power.

# Without encapsulation — dangerous, fragile
class BankAccountBad:
    def __init__(self, balance):
        self.balance = balance

account = BankAccountBad(1000)
account.balance = -99999
print(account.balance)

# With encapsulation — safe, reliable
class BankAccount:
    def __init__(self, owner: str, initial_balance: float):
        self.__owner = owner
        self.__balance = initial_balance
        self.__transaction_log = []

    @property
    def balance(self) -> float:
        return self.__balance

    def deposit(self, amount: float) -> None:
        if amount <= 0:
            raise ValueError("Deposit must be positive.")
        self.__balance += amount
        self.__transaction_log.append(f"+ {amount}")

    def withdraw(self, amount: float) -> None:
        if amount > self.__balance:
            raise ValueError("Insufficient funds.")
        self.__balance -= amount
        self.__transaction_log.append(f"- {amount}")

account = BankAccount("Glenn", 1000.00)
account.deposit(500)
print(account.balance)

class UserProfile:
    def __init__(self, username, email, password):
        self.username = username
        self._email = email
        self.__password_hash = self._hash(password)

    def _hash(self, raw: str) -> str:
        return f"hashed_{raw}"

    def verify_password(self, attempt: str) -> bool:
        return self.__password_hash == self._hash(attempt)

user = UserProfile("Glenn", "glenn@example.com", "secret123")
print(user.username)
print(user._email)
print(user.verify_password("secret123"))
print(user.verify_password("wrongpass"))

class Temperature:
    def __init__(self, celsius: float):
        self.celsius = celsius

    @property
    def celsius(self) -> float:
        return self.__celsius

    @celsius.setter
    def celsius(self, value: float) -> None:
        if value < -273.15:
            raise ValueError(f"Temperature {value}°C is below absolute zero!")
        self.__celsius = value

    @property
    def fahrenheit(self) -> float:
        return (self.__celsius * 9 / 5) + 32

    @property
    def kelvin(self) -> float:
        return self.__celsius + 273.15

    def __repr__(self) -> str:
        return f"Temperature({self.__celsius}°C / {self.fahrenheit}°F / {self.kelvin}K)"

t = Temperature(100)
print(t.celsius)
print(t.fahrenheit)
print(t.kelvin)
t.celsius = 0

class DataPipeline:
    def __init__(self, name: str):
        self.__name = name
        self.__steps = []
        self.__is_running = False
        self.__results = {}

    @property
    def name(self) -> str:
        return self.__name

    @property
    def step_count(self) -> int:
        return len(self.__steps)

    @property
    def is_running(self) -> bool:
        return self.__is_running

    def add_step(self, step_fn, step_name: str) -> "DataPipeline":
        if self.__is_running:
            raise RuntimeError("Cannot modify a running pipeline.")
        self.__steps.append((step_name, step_fn))
        return self

    def run(self, data):
        self.__is_running = True
        current = data
        for name, step in self.__steps:
            current = step(current)
            self.__results[name] = current
        self.__is_running = False
        return current

    def get_result(self, step_name: str):
        return self.__results.get(step_name)

class APIClient:
    def __init__(self, api_key: str, model: str = "gpt-4o"):
        self.__api_key = api_key
        self.__model = model
        self.__token_count = 0
        self.__cache = {}
        self.__retry_limit = 3

    @property
    def tokens_used(self) -> int:
        return self.__token_count

    def ask(self, prompt: str, use_cache: bool = True) -> str:
        if use_cache and prompt in self.__cache:
            return self.__cache[prompt]
        response = self.__call_api_with_retry(prompt)
        self.__cache[prompt] = response
        return response

    def __call_api_with_retry(self, prompt: str) -> str:
        for attempt in range(self.__retry_limit):
            pass
        return "[response]"

client = APIClient(api_key="sk-...")
answer = client.ask("Explain encapsulation in one sentence.")
print(f"Tokens used: {client.tokens_used}")

from dataclasses import dataclass, field

@dataclass
class Product:
    name:     str
    _price:   float  = field(repr=False)
    _stock:   int   = field(default=0, repr=False)

    def __post_init__(self):
        if self._price < 0:
            raise ValueError("Price cannot be negative.")

    @property
    def price(self) -> float:
        return self._price

    @price.setter
    def price(self, value: float) -> None:
        if value < 0:
            raise ValueError("Price cannot be negative.")
        self._price = value

class SensorReading:
    __slots__ = ('_timestamp', '_value', '_unit')
    def __init__(self, value, unit):
        self._timestamp = time.time()
        self._value = value
        self._unit = unit
    @property
    def value(self):
        return self._value