design pattern_SOLID

You have created a set of services that implement the same API, but depending on the source (i.e. where the data is read from), it implements different business logic. 
How would you do this considering the Liskov Substitution principle?

Make the caller unaware of the reader they are using. In fact abstract the reader through an abstract Reader class
from which the other classes are derived and only read through the abstracted memthods.


factory method
- helper:
  class ShapeType(Enum) # self-documenting
  class ShapeContext # container store to hold factory parameters
- main
  class Shape(ABC) # abstract class
  class ShapeFactory # create concret classes
  class Circle(Shape) # concret class
  class Rectangle(Shape) # concret class


from abc import ABC, abstractmethod

class Computer:
    def __init__(self,processor=None,memory=None,storage=None,graphics_card=None,operating_system=None,extras=None):
        # Initialize the attributes
        self.processor = processor
        self.memory = memory
        self.storage = storage
        self.graphics_card = graphics_card
        self.operating_system = operating_system
        self.extras = extras
        

class ComputerBuilder(ABC):
    @abstractmethod
    def add_processor(self):
        pass

    @abstractmethod
    def add_memory(self):
        pass

    @abstractmethod
    def add_storage(self):
        pass

    @abstractmethod
    def add_graphics_card(self):
        pass

    @abstractmethod
    def add_operating_system(self):
        pass

    @abstractmethod
    def add_extras(self):
        pass

class CustomComputerBuilder(ComputerBuilder):
    def __init__(self):
        # Initialize a Computer object
        self.computer = Computer()

    # Override abstract methods and set Computer attributes
    def add_processor(self,value):
        self.computer.processor = value

    def add_memory(self,value):
        self.computer.memory = value

    def add_storage(self,value):
        self.computer.storage = value

    def add_graphics_card(self,value):
        self.computer.graphics_card = value

    def add_operating_system(self,value):
        self.computer.operating_system = value

    def add_extras(self,value):
        self.computer.extras = value

class ComputerDirector:
    def __init__(self, builder):
        # Initialize the builder instance
        self.builder = builder

    def build_computer(self, specs):
        # Call the add_* methods of the builder with the specs
        # self.builder.add_processor(specs['processor'])
        # self.builder.add_memory(specs['memory'])
        # self.builder.add_storage(specs['storage'])
        # self.builder.add_graphics_card(specs['graphics_card'])
        # self.builder.add_operating_system(specs['operating_system'])
        # self.builder.add_extras(specs['extras'])
        for i,j in specs.items():
            getattr(self.builder,f'add_{i}')(j)

# Helper function to test the computer building process
def test_computer_building(specs, expected_output):
    builder = CustomComputerBuilder()
    director = ComputerDirector(builder)
    director.build_computer(specs)
    computer = builder.computer
    assert computer.__dict__ == expected_output, f"Expected {expected_output}, but got {computer.__dict__}"

# Test cases
test_specs = {
    'processor': 'Intel Core i5',
    'memory': '8GB',
    'storage': '512GB SSD',
    'graphics_card': 'Integrated',
    'operating_system': 'Windows 11',
    'extras': ['Wi-Fi']
}

expected_output = {
    'processor': 'Intel Core i5',
    'memory': '8GB',
    'storage': '512GB SSD',
    'graphics_card': 'Integrated',
    'operating_system': 'Windows 11',
    'extras': ['Wi-Fi']
}

test_computer_building(test_specs, expected_output)

print("All tests passed!")


**********************************************************************************************************************************************************************************
State Design Pattern

from abc import ABC, abstractmethod

# Step 1: Define the abstract base class TicketState
class TicketState(ABC):

    @abstractmethod
    def assign(self, ticket):
        pass

    @abstractmethod
    def resolve(self, ticket):
        pass

    @abstractmethod
    def close(self, ticket):
        pass

# Step 2: Implement the concrete state classes
class NewState(TicketState):

    def assign(self, ticket):
        # Implement the behavior for assigning a new ticket
        ticket.state = AssignedState()
        print("Ticket has been assigned.")

    def resolve(self, ticket):
        # Implement the behavior for resolving a new ticket
        print("Cannot resolve a new ticket. Assign it first.")

    def close(self, ticket):
        # Implement the behavior for closing a new ticket
        ticket.state = ClosedState()
        print("Ticket has been closed.")

# Implement the other concrete state classes: AssignedState, ResolvedState, and ClosedState
class AssignedState(TicketState):
    def assign(self, ticket):
        # Implement the behavior for assigning a new ticket
        print("Ticket is already assigned.")
    
    def resolve(self, ticket):
        # Implement the behavior for resolving a new ticket
        ticket.state = ResolvedState()
        print("Ticket has been resolved.")

    def close(self, ticket):
        # Implement the behavior for closing a new ticket
        ticket.state = ClosedState()
        print("Ticket has been closed.")

class ResolvedState(TicketState):
    def assign(self, ticket):
        # Implement the behavior for assigning a new ticket
        print("Cannot assign a resolved ticket.")
    
    def resolve(self, ticket):
        # Implement the behavior for resolving a new ticket
        print("Ticket is already resolved.")

    def close(self, ticket):
        # Implement the behavior for closing a new ticket
        ticket.state = ClosedState()
        print("Ticket has been closed.")
    
class ClosedState(TicketState):
    def assign(self, ticket):
        # Implement the behavior for assigning a new ticket
        print("Cannot assign a closed ticket.")
    
    def resolve(self, ticket):
        # Implement the behavior for resolving a new ticket
        print("Cannot resolve a closed ticket.")

    def close(self, ticket):
        # Implement the behavior for closing a new ticket
        print("Ticket is already closed.")    

# Step 3: Implement the Ticket class
class Ticket:

    def __init__(self):
        # Initialize the ticket's state attribute with an instance of the NewState class
        self.state = NewState()

    def assign(self):
        # Delegate the assign method call to the current state object
        self.state.assign(self)

    def resolve(self):
        # Delegate the resolve method call to the current state object
        self.state.resolve(self)

    def close(self):
        # Delegate the close method call to the current state object
        self.state.close(self)

# Step 4: Test the behavior of the ticket and its state transitions
def main():
    ticket = Ticket()

    # Test the initial state and transitions
    ticket.assign()
    ticket.resolve()
    ticket.close()

    # Test invalid transitions
    ticket.assign()
    ticket.resolve()

if __name__ == "__main__":
    main()