Fixing Abstract Factory in Python

I'm trying to implement Abstract Factory pattern in Python, but after creating new "product" it simply does not work and I can't firuge out what's the problem. Here's a code:

`from __future__ import annotations
from abc import ABC, abstractmethod
# AbstractFactory
class AbstractCarFactory(ABC):
@abstractmethod
def create_product_car(self) -> AbstractProductCar:
    pass

@abstractmethod
def create_product_engine(self) -> AbstractProductEngine:
    pass

@abstractmethod
def create_product_wheel(self) -> AbstractProductWheel:
    pass


class FordFactory(AbstractCarFactory):
def create_product_car(self) -> AbstractProductCar:
    return Ford()

def create_product_engine(self) -> AbstractProductEngine:
    return FordEngine()

def create_product_wheel(self) -> AbstractProductWheel:
    return FordWheel()


class ToyotaFactory(AbstractCarFactory):
def create_product_car(self) -> AbstractProductCar:
    return Toyota()

def create_product_engine(self) -> AbstractProductEngine:
    return ToyotaEngine()

def create_product_wheel(self) -> AbstractProductWheel:
    return ToyotaWheel()


class MercedesFactory(AbstractCarFactory):
def create_product_car(self) -> AbstractProductCar:
    return Mercedes()

def create_product_engine(self) -> AbstractProductEngine:
    return MercedesEngine()

def create_product_wheel(self) -> AbstractProductWheel:
    return MercedesWheel()


class AbstractProductCar(ABC):
@abstractmethod
def info_car(self) -> str:
    pass

def interact1_car(self, collaborator: AbstractProductEngine) -> str:
    pass

def interact2_car(self, collaborator: AbstractProductWheel) -> str:
    pass


class AbstractProductEngine(ABC):
@abstractmethod
def get_power(self) -> str:
    pass


class FordEngine(AbstractProductEngine):
def get_power(self) -> str:
    return "Ford Engine"


class ToyotaEngine(AbstractProductEngine):
def get_power(self) -> str:
    return "Toyota Engine"


class MercedesEngine(AbstractProductEngine):
def get_power(self) -> str:
    return "Mercedes Engine"


class AbstractProductWheel(ABC):
@abstractmethod
def get_wheel(self) -> str:
    pass


class FordWheel(AbstractProductWheel):
def get_wheel(self) -> str:
    return "Ford Wheel"


class ToyotaWheel(AbstractProductWheel):
def get_wheel(self) -> str:
    return "Toyota Wheel"


class MercedesWheel(AbstractProductWheel):
def get_wheel(self) -> str:
    return "Mercedes Wheel"


class Ford(AbstractProductCar):
def info_car(self) -> str:
    return "Ford"

def interact1_car(self, collaborator: AbstractProductEngine) -> str:
    result1 = self.info_car() + " set Engine " + collaborator.get_power()
    return f"Result of setting engine to the body: ({result1})"

def interact2_car(self, collaborator: AbstractProductWheel) -> str:
    result2 = self.info_car() + " set Wheels " + collaborator.get_wheel()
    return f"Result of final assembly: {result2}"


class Toyota(AbstractProductCar):
def info_car(self) -> str:
    return "Toyota"

def interact1_car(self, collaborator: AbstractProductEngine) -> str:
    result1 = self.info_car() + " set Engine " + collaborator.get_power()
    return f"Result of setting engine to the body: ({result1})"

def interact2_car(self, collaborator: AbstractProductWheel) -> str:
    result2 = self.info_car() + "set Wheels " + collaborator.get_wheel()
    return f"Result of final assembly: {result2}"


class Mercedes(AbstractProductCar):
def info_car(self) -> str:
    return "Mercedes"

def interact1_car(self, collaborator: AbstractProductEngine) -> str:
    result1 = self.info_car() + " set Engine " + collaborator.get_power()
    return f"Result of setting engine to the body: ({result1})"

def interact2_car(self, collaborator: AbstractProductWheel) -> str:
    result2 = self.info_car() + "set Wheels " + collaborator.get_wheel()
    return f"Result of final assembly: {result2}"

def client_code(factory: AbstractCarFactory) -> None:
product_a = factory.create_product_car()
product_b = factory.create_product_engine()


print(f"{product_a.interact1_car(product_b)}"
     f"{product_a.interact2_car(product_b)}")


if __name__ == "__main__":
print("Client: Testing first factory:")
client_code(FordFactory())

print("Client: Testing second factory:")
client_code(ToyotaFactory())

print("Client: Testing third factory:")
client_code(MercedesFactory())

I've already tried to create abstract client code instead of copying it every time but it doesn't help. Even ChatGPT can't tell what's te matter lol

I'm assuming the code you've sent was indented incorrectly when copying and pasting as a lot of the methods for classes are inline with the class definition. After fixing that I ran your code and got:

python3 test.py     
Client: Testing first factory:
NoneNone
Client: Testing second factory:
Traceback (most recent call last):
  File "/Users/jamied/git/pseudocode/test.py", line 157, in <module>
    client_code(ToyotaFactory())
  File "/Users/jamied/git/pseudocode/test.py", line 149, in client_code
    f"{product_a.interact2_car(product_b)}")
  File "/Users/jamied/git/pseudocode/test.py", line 127, in interact2_car
    result2 = self.info_car() + "set Wheels " + collaborator.get_wheel()
AttributeError: 'ToyotaEngine' object has no attribute 'get_wheel'

It looks like the second method you created interact2_car was meant to interact with a AbstractProductWheel class but instead you gave it a AbstractProductEngine class. Maybe this is what you meant to do?

def client_code(factory: AbstractCarFactory) -> None:
    product_a = factory.create_product_car()
    product_b = factory.create_product_engine()
    product_c = factory.create_product_wheel() # I added this


    print(f"{product_a.interact1_car(product_b)}"
        f"{product_a.interact2_car(product_c)}") # now using product c

Then running this gives

python3 test.py
Client: Testing first factory:
Result of setting engine to the body: (Ford set Engine Ford Engine)Result of final assembly: Ford set Wheels Ford Wheel
Client: Testing second factory:
Result of setting engine to the body: (Toyota set Engine Toyota Engine)Result of final assembly: Toyotaset Wheels Toyota Wheel
Client: Testing third factory:
Result of setting engine to the body: (Mercedes set Engine Mercedes Engine)Result of final assembly: Mercedesset Wheels Mercedes Wheel

Which is hopefully what you wanted?

ps. it's usually helpful to post the error message when asking a question like this, it makes it easier to see what the problem is.