Factory & Composite Design Patterns combo in Python & circular imports-CodePudding

I've built a couple projects now using the composite pattern where the objects hierarchy is built from a configuration file. My problem is that I's like to save each subclass in a separate file, to allow extensions without changing the base classes' files or having huge files. Each object once instantiated is then going to instantiate a different subclass, based on a type listed in its configuration. To do this I thought of including a factory function which will live in its own file, import all accessible subclasses, and contain a single function that will just return the appropriate subclass based on the name passed to it. The problem with this, is that each of those subclass modules, in order to use this factory, must import it. This creates a circular import situation since the factory module imports all subclasses which all import it back. How can this be avoided or is there a cleaner way to instantiate a subclass dynamically within another ?

As an example - I wrote a "Pipeline" project, useful for automation of different procedures I often need to repeat. The basic parent class is called "Block", it is inherited from to create blocks that comply with a certain interface (i.e. other projects that perform actions) and from those I inherit to blocks that actually execute specific operations. A block only needs to see the its successor in the pipeline, and does not care weather this is a single block or an entire, separate pipeline. To implement this I want each block to instantiate its successor based on the order defined in the config file that is passed along the chain. If I were to write a file that imports all implemented concrete blocks and returns whichever one requested, then I wouldn't be able to import it for use in any of the concrete blocks' modules, since they are imported into the factory one in order to be available for instantiation themselves.

CodePudding user response：

You know that if you write your import statement itself inside a method or function, it will only be executed after all module-level classes and functions have been defined, right? Your circular-dependency can be fixed as simply as writing a "factory" method in the base class that will contain a from factory import factory_function statement and call it.


# basemodel.py  Base file
class Base:
   def factory(self, *args, **kw):
       from factory import factory_function

# baseblock.py Block class hierarchy base file
from basemodel import Base
class Block(Base):
    ...

# blockXX.py Other block classes files:
from baseblock import Block

class SpecializedBlock31(Block):
    ...

# factory.py:

from block import Block
...
from block31 import Block31
...
# (or some dynamic importing using __import__ and looking at the filesystem)

def factory_function(*args, **kw):
    # logic to decide which class to use
    ...
    instance = decided_class(...)
    return instance