class Action:
    def __init__(self, operator):
        self.Operator = operator
    
    def Calculate(self, a, b):
        return self.Operator(a,b)


class Calculator:
    def __init__(self):
        self.FancyCalculate = Action(lambda a,b: a + b + 5)

c = Calculator()
c.FancyCalculate(1,2)
c.FancyCalculate = Action(lambda a,b: a + b + 10)
c.FancyCalculate(1,2)

class Singleton:
    _instance = None 

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

    def __init__(self):
        self.value = None 

class MyClass:
    def __init(self):
        self.value = None

myInstance = MyClass() 

class State:
    def __init__(self,name, nextStateName, operator):
        self.name = name
        self.nextStateName = nextStateName
        self.operator = operator

class StateMachine:
    def __init__(self, states):
        self.states = {}
    
    def AddState(self, name, operator, nextState):
        self.states[name] = State(name, nextState, operator)

    def RemoveState(self,name):
        del self.states[name]

from abc import ABC, abstractmethod

class LightState(ABC):
    @abstractmethod
    def switch_on(self, light_switch):
        pass

    @abstractmethod
    def switch_off(self, light_switch):
        pass

class OnState(LightState):
    def switch_on(self, light_switch):
        print("The light is already ON.")

    def switch_off(self, light_switch):
        print("Turning the light OFF.")
        light_switch.set_state(OffState())

class OffState(LightState):
    def switch_on(self, light_switch):
        print("Turning the light ON.")
        light_switch.set_state(OnState())

    def switch_off(self, light_switch):
        print("The light is already OFF.")

class LightSwitch:
    def __init__(self):
        self.state = OffState()  # Initial state is "Off"

    def set_state(self, new_state):
        self.state = new_state

    def switch_on(self):
        self.state.switch_on(self)

    def switch_off(self):
        self.state.switch_off(self)

    def get_state(self):
        return self.state.__class__.__name__

light_switch = LightSwitch()

print(f"Initial State: {light_switch.get_state()}")
light_switch.switch_on()
print(f"Current State: {light_switch.get_state()}")
light_switch.switch_off() 
print(f"Current State: {light_switch.get_state()}")

class Observer:
    def update(self, temperature):
        pass


class WeatherStation:
    def __init__(self):
        self.observers = []
        self.temperature = None

    def add_observer(self, observer):
        self.observers.append(observer)

    def remove_observer(self, observer):
        self.observers.remove(observer)

    def set_temperature(self, temperature):
        self.temperature = temperature
        self.notify_observers()

    def notify_observers(self):
        for observer in self.observers:
            observer.update(self.temperature)


class Display(Observer):
    def update(self, temperature):
        print(f"Current temperature: {temperature}°C")

weather_station = WeatherStation()
display = Display()

weather_station.add_observer(display)

weather_station.set_temperature(25)

class WeatherStation:
    def GetTemperature(self):
        self.get_temp_from_service()

    def get_temp_from_service(self):
        # Some http request
        return 27


class Display(Observer):
    def __init__(self, weatherStation):
        self.weatherStation = weatherStation

    def Display(self):
        print(f"Current temperature: {self.weatherStation.GetTemperature()}°C")

weather_station = WeatherStation()
display = Display(weather_station)

# Some other location of code
display.Display()