class Cat

def __init__(self, name: str, paw: str) -> None

def sneak(self) -> None

def react(self) -> None

# Define ingredients (data)
flour = '2 cups'
milk = '1 cup'
egg = '1'

# Step-by-step functions
def mix_ingredients() -> None:
    print(f'Mix {flour}, {milk}, and {egg} together.')

def cook_pancake() -> None:
    print('Pour batter onto pan and cook.')

def serve() -> None:
    print('Pancake is ready to eat!')

# Call functions in order
mix_ingredients()
cook_pancake()
serve()

class Pancake:
    def __init__(self, flour: str, milk: str, egg: str) -> None:
        self.flour = flour
        self.milk = milk
        self.egg = egg

    def mix(self) -> None:
        print(f'Mix {self.flour}, {self.milk}, and {self.egg} together.')

    def cook(self) -> None:
        print('Pour batter onto pan and cook.')

    def serve(self) -> None:
        print('Pancake is ready to eat!')

# Create a Pancake object
my_pancake = Pancake('2 cups', '1 cup', '1')
my_pancake.mix()
my_pancake.cook()
my_pancake.serve()

class Mom:
    def say_hello(self) -> str:
        return 'Hello! 👋'

class Child(Mom):
    pass # here the instance of Child class will be having say_hello method 

class Granddad:
    def say_hello(self) -> str:
        return 'Hello!'

class Dad(Granddad):
    def say_bye(self) -> str:
        return 'bye!'

class Child(Dad):
    pass # Child can say_bye and say_hello inheriting everything from Dad only. Dad also inherited say_hello from granddad

class Parent:
    def talk(self) -> str:
        return 'I’m the parent!'

class Child(Parent):
    def talk(self) -> str:
        return 'I’m the child!' # here we override the method talk inherited from Parent

class Parent:
    def introduce(self) -> str:
        return 'I’m the parent!'

class Child(Parent):
    def introduce(self) -> str:
        return f'{super().introduce()} And I’m the child!'

class Toy:
   def play(self) -> str:
       return 'Let's play! 🎮'

toy = Toy()
print(toy.play())  # Everyone can use it!

class Animal:
    def __init__(self) -> None:
        self._kind = 'Unknown'  # Protected attribute

    def show_kind(self):
        return f'This is an {self._kind}.'

class Dog(Animal):
    def __init__(self) -> None:
        super().__init__()
        self._kind = 'Dog'

pet = Dog()
print(pet.show_kind())  # Dog 🐶

class Safe:
    def __init__(self) -> None:
        self.__secret = 'Shhh... It is a secret! 🤫'  # Private attribute

    def reveal_secret(self) -> str:
        return self.__secret

my_safe = Safe()
print(my_safe.reveal_secret())  # You can access it safely!

class BankAccount:
    def __init__(self, balance: int) -> None:
        self.__balance = balance  # Private attribute

    def get_balance(self) -> str:  # Getter
        return f'Your balance is ${self.__balance}'

    def set_balance(self, amount: int) -> str:  # Setter
        if amount >= 0:
            self.__balance = amount
            return 'Balance updated! ✅'
        else:
            return 'Invalid amount! ❌'

# Using the class
account = BankAccount(100)
print(account.get_balance())  # Get the balance
print(account.set_balance(200))  # Update the balance
print(account.get_balance())

class Calculator:
    def add(self, *args) -> int:
        return sum(args)  # Add any number of values!

calc = Calculator()
print(calc.add(1, 2))  # 3
print(calc.add(1, 2, 3, 4))  # 10

class Parent:
    def talk(self) -> str:
        return 'I’m the parent!'

class Child(Parent) -> str:
    def talk(self):
        return 'I’m the child!' # here we override the method talk inherited from Parent

from typing import Protocol, runtime_checkable

@runtime_checkable
class SwimmingAnimal(Protocol):
    def swim(self) -> str:
        pass
        
class Duck:
    def swim(self) -> str:
        return 'Splash! Duck swimming!'

class Fish:
    def swim(self) -> str:
        return 'Swish! Fish swimming!'

def make_it_swim(creature: SwimmingAnimal) -> None:
    print(creature.swim())

duck = Duck()
fish = Fish()
make_it_swim(duck)  # Duck swimming
make_it_swim(fish)  # Fish swimming
print(isinstance(duck, SwimmingAnimal)) # returns True, since we have @runtime_checkable and Duck satisfies the Protocol of SwimmingAnimal by implementing the swim method

from typing import List

from abc import ABC, abstractmethod

from itertools import zip_longest

class Multiplier:
    def __init__(self, values):
        self.values = values

    # ❗ When we use - on an object
    def __neg__(self):
        return Multiplier([-value for value in self.values])

    # ❗ When we use abs() on an object
    def __abs__(self):
        return Multiplier([abs(value) for value in self.values])

    def __iter__(self):
        return (value for value in self.values)

    # ❗ When we add two objects (+)
    def __add__(self, other):
        longest_items = zip_longest(self, other, fillvalue=0)
        return Multiplier([a + b for a, b in longest_items])  # Creates a new object

multiplier = Multiplier([1, 5])
print((-multiplier).values)  # [-1, -5]

multiplier2 = Multiplier([-1, 5, -1, 15, -10])
print(abs(multiplier2).values)  # [1, 5, 1, 15, 10]

print((multiplier + multiplier2).values)  # [0, 10, -1, 15, -10]

class Person:
    def __init__(self, names):
        self.names = names

    def __iadd__(self, other):
        if not isinstance(other, Person):
            return NotImplemented  
        self.names.extend(other.names)  # Extending the list of names
        return self  

person1 = Person(['Jack', 'John'])
person2 = Person(['Jason', 'Viktor'])

print(id(person1))  # Same ID before +=
person1 += person2
print(id(person1))  # Same ID after += (object updated, not replaced!)

print(person1.names)  # ['Jack', 'John', 'Jason', 'Viktor']

class Person:
    def __init__(self, names):
        self.names = names

    def __getitem__(self, position):
        return self.names[position]  # Allows indexing (e.g., person[0])

    def __len__(self):
        return len(self.names)  # Allows len(person)

    def __iter__(self):
        return (name for name in self.names)  # Allows iteration

person1 = Person(['Nik', 'Michael'])

print(', '.join(person1))  # "Nik, Michael"
print(len(person1))  # 2
print(person1[0])  # "Nik"

class Person:
    __match_args__ = ('Name1', 'Name2')

    def __init__(self, names):
        self.names = names

    def __setattr__(self, attr, value):
        super().__setattr__(attr, value)  # Default behavior

    def __getattr__(self, attr):
        _cls = type(self)
        if attr in _cls.__match_args__:
            index = _cls.__match_args__.index(attr) # looking for index of attribute in __match_args__
            return self.names[index] # calling this index on self.names
        raise AttributeError(f'Attribute {attr} not found!')

person1 = Person(['Michael', 'Nik'])
person1.Name2 = 'Gregor'  # Overwriting the second name
print(person1.Name2)  # "Gregor"

class CustomDict(dict):
    def __missing__(self, key):
        if isinstance(key, str):
            raise KeyError(key)
        return self[str(key)]  # Convert non-string keys to strings

    def get(self, key, default=None):
        try:
            return self[key]
        except KeyError:
            return default  # Default value if key is missing

    def __contains__(self, key):
        return str(key) in self.keys() or key in self.keys()  # Allow searching both str & int keys

my_dict = CustomDict({'1': 2, 2: 3})
print(my_dict[1])  # 2 (since '1' is converted)
print(1 in my_dict)  # True (searching for 1 also finds '1')

from collections import UserDict

class UpperCaseSearcher:
    def __setitem__(self, key, value):
        super().__setitem__(key.upper(), value)  # Converts keys to uppercase

    def __getitem__(self, key):
        return super().__getitem__(key.upper())

    def __contains__(self, key):
        return super().__contains__(key.upper())

    def get(self, key, default=None):
        return super().get(key.upper(), default)

class CaseInsensitiveDict(UpperCaseSearcher, UserDict):
    ...

test_dict = CaseInsensitiveDict({'a': 1, 'b': 2, 'c': 3})

print(test_dict.keys())  # Outputs: dict_keys(['A', 'B', 'C'])
print(test_dict['A'])    # Outputs: 1

class OriginalClass:
    def original_method(self, value):
        print(f"Original value: {value}")

class Mixin:
    def original_method(self, value, additional_value):
        new_value = f"{value}, {additional_value}"
        super().original_method(new_value)  # Calls the original method

class AdaptedClass(Mixin, OriginalClass):
    pass

adapted_instance = AdaptedClass()
adapted_instance.original_method("test", "one more method")  
# Outputs: Original value: test, one more method

# Metaclass Example: Using the 'type' function to create a class dynamically
MetaClass = type('MetaClass', (object,), {'x': '12'})

# The same as writing:
class MetaClass:
    x = '12'

from typing import Callable, List

def create_dynamic_class(name: str, attr: List, callables: List[Callable]) -> Callable:
    def __init__(self, *args, **kwargs) -> None:
        attrs = dict(zip(attr, args)) 
        attrs.update(kwargs) # sets kwargs dict as attributes

        for key, value in attrs.items():
            setattr(self, key, value) # sets args list as attributes

        for index, cal in enumerate(callables): 
            setattr(self, cal, __fetch_callables(index))

    def __repr__(self) -> str:
        return f'attributes: {self.__dict__}'

    def __fetch_callables(index: int) -> Callable:
        return lambda: print(f'I am callable {index}') # returns callable (function / method) for each of the index of callables 

    cls_attr = dict(
        __init__=__init__,
        __repr__ = __repr__
    )# attributes of the class itself - it has __init__ -> initialisor we defined above which assigns attributes and methods to the instance of the class

    return type(name, (object,), cls_attr)

TestClass = create_dynamic_class('NewClass', ['x', 'y', 'z'], ['call_me1', 'call_me2', 'call_me3'])

test_instance = TestClass(z=12, s=10)
print(test_instance.__dict__)
print(test_instance.call_me3())

def i_am_function():
    print('Stop changing me!')

# Custom Metaclass to change class attributes
class Meta(type):
    def __new__(cls, name, bases, attributes):
        print(cls)  # <class '__main__.Meta'>
        print(name)  # Test1
        print(bases)  # (<class '__main__.Base'>, <class '__main__.Another'>)
        print(attributes)  # {'__module__': '__main__', '__qualname__': 'Test1', 'a': 10}

        # Changing the class attributes to uppercase
        new_attributes = {key.upper(): value for key, value in attributes.items()}
        new_attributes['TEST_METHOD'] = i_am_function  # Add a new method to the class

        # Checking if the class has a specific method
        if 'I_AM_HERE' not in new_attributes:
            raise ValueError(f'I AM HERE NOT HERE {cls.__name__}')

        return super().__new__(cls, name, bases, new_attributes)  # Creating class with modified attributes

class Base(metaclass=Meta):
    def i_am_here(self):
        ...

class Another:
    ...

class Test1(Base, Another):
    a = 10

    def test_method(self):
        print('test')

    def i_am_here(self):
        ...# will raise a value error if not available

# Displaying class attributes
print(Test1.__dict__)
#{'__MODULE__': '__main__', '__QUALNAME__': 'Test1', '__FIRSTLINENO__': 29, 'A': 10, 'TEST_METHOD': <function i_am_function at 0x118815bc0>, 'I_AM_HERE': <function Test1.i_am_here at 0x118816020>, '__STATIC_ATTRIBUTES__': (), '__module__': '__main__', '__doc__': None}

# Calling the dynamically added method
Test1.TEST_METHOD()  # Will print "Stop changing me!"

from dataclasses import dataclass

@dataclass
class Person:
    age: int = 27
    weight: int = 80
    height: int = 183

person = Person()
print(person)  # Output: Person(age=27, weight=80, height=183)

from dataclasses import dataclass

@dataclass(frozen=True)
class Person:
    name: str
    age: int = 12

person = Person('Nik', 10)
# person.age = 15  # ❌ This will cause an error because it's frozen!

@dataclass(frozen=True)
class Person:
    name: str
    age: int = 12

person1 = Person('Nik', 10)
person2 = Person('Nik', 10)

print(hash(person1))  # ✅ Works because of frozen=True
print(hash(person2))
print(person1 == person2)  # ✅ True, because they have the same values
print(id(person1), id(person2))  # ❌ Different IDs (because they are different objects) - here compared based on hash values not on ids

@dataclass
class Person:
    partners: list = []  # ❌ This causes an error because lists are mutable and there can be memory leaks

from dataclasses import field

@dataclass
class Person:
    partners: list = field(default_factory=list)  # ✅ Each person gets a new list

person1 = Person()
person2 = Person()

person1.partners.append("Alice")
print(person1.partners)  # ['Alice']
print(person2.partners)  # [] (Not shared!)

@dataclass
class Person:
    name: str
    statuses: list = field(default_factory=list)

    def __post_init__(self):
        if self.name == "Nik":
            print(f"Warning! Name cannot be 'Nik'")

person = Person('Nikola')  # ✅ Works fine
person_nik = Person('Nik')  # ⚠️ Prints warning

class Person:
    def __init__(self, names=[]):  # ⚠️ Oops! This is dangerous!
        self.names = names  # This list is SHARED with other people!

    def append_name(self, name):
        self.names.append(name)

# 🎭 Different people with different lists
person1 = Person(['Migel', 'Benjamin'])  # This person brings their OWN list
person2 = Person()  # This person does NOT bring a list
person3 = Person()  # This person also does NOT bring a list

# 👀 Let's add a new name to person2
person2.append_name('Lupin')

# 😲 Oh no! Person3 also has "Lupin" in their list!
print(person3.names)  # Output: ['Lupin']

# 🎭 The trick is that person2 and person3 SHARE the same list!
print(id(person1.names), id(person2.names), id(person3.names))  # Same ID for person2 and person3 (lists are shared)!

class Person:
    def __init__(self, names=None):  # ❌ Don't use mutable default values
        self.names = names if names is not None else []  # ✅ Create a new list for each person!

class AnotherPerson(Person):
    ...
    
another_person = AnotherPerson('Jocker', 'Unknown')
print(another_person.__dict__)  # ✅ Works! Creates a dictionary automatically by default

class OneMorePerson(Person):
    __slots__ = ()  # ❌ No extra attributes allowed!

one_more_person = OneMorePerson('Bruce', 'Wayne')
#print(one_more_person.__dict__)  # ❌ ERROR! No __dict__, and no extra slots allowed!