Подходы к реализации паттерна Фабрика в Python

class ClassNotFoundError(ValueError):     ...   class SubjectOne(object):     ...   class SubjectTwo(object):     ...   class Factory(object):     @staticmethod     def get(class_name: str) -> object:         if type(class_name) != str:             raise ValueError("class_name must be a string!")          if class_name == "SubjectOne":             return SubjectOne          if class_name == "SubjectTwo":             return SubjectTwo          raise ClassNotFoundError   # Usage class_ = Factory.get("SubjectOne") 

from typing import Hashable, Callable   class ClassNotFoundError(ValueError):     ...   class SubjectOne(object):     ...   class SubjectTwo(object):     ...   class Factory(object):     @staticmethod     def get(class_name: Hashable) -> object:         if not isinstance(class_name, Hashable):             raise ValueError("class_name must be a Hashable type!")                  classes: dict[Hashable, Callable[..., object]] = {             "SubjectOne": SubjectOne,             "SubjectTwo": SubjectTwo         }          class_ = classes.get(class_name, None)         if class_ is not None:             return class_          raise ClassNotFoundError   # Usage class_ = Factory.get("SubjectOne") 

class ClassNotFoundError(ValueError):     ...   class SubjectOne(object):     ...   class SubjectTwo(object):     ...   class Factory(object):     @staticmethod     def get(class_name: str) -> object:         if type(class_name) != str:             raise ValueError("class_name must be a string!")          try:             instance_ = eval(f"{class_name}()")             return instance_         except Exception as e:             from warnings import warn             warn(str(e))              raise ClassNotFoundError   # Usage instance_ = Factory.get("SubjectTwo") 

class ClassNotFoundError(ValueError):     ...   class SubjectOne(object):     ...   class SubjectTwo(object):     ...   class Factory(object):     @staticmethod     def get(class_name: str) -> object:         if type(class_name) != str:             raise ValueError("class_name must be a string!")          class_ = globals().get(class_name, None)         if class_ is not None:             return class_          raise ClassNotFoundError   # Usage class_ = Factory.get("SubjectTwo") 

from typing import Callable   class ClassNotFoundError(ValueError):     ...   class FactorySubject(object):     ...   class SubjectOne(FactorySubject):     ...   class SubjectTwo(FactorySubject):     ...   class Factory(object):     @staticmethod     def get(class_name: str) -> object:         if type(class_name) != str:             raise ValueError("class_name must be a string!")          raw_subclasses_ = FactorySubject.__subclasses__()         classes: dict[str, Callable[..., object]] = {c.__name__:c for c in raw_subclasses_}         class_ = classes.get(class_name, None)         if class_ is not None:             return class_          raise ClassNotFoundError   # Usage class_ = Factory.get("SubjectTwo") 

Абстрактный класс фабрики

import importlib import logging import os from abc import ABC, abstractmethod from functools import cache from pathlib import Path from types import ModuleType from typing import Callable, Hashable, TypeVar, Generic  debug_logger = logging.getLogger("debug")  T = TypeVar("T")  CallableClass = Callable[..., T]   class AbstractFactory(Generic[T], ABC):     """     AbstractFactory     ===============      Class properties     ----------------      modules_dir: Path         A path to dir with desired modules,         which we want to get from our Factory.      parent_package: str         Full parent package path.         Example: src.high_package.low_package      filter_files: list[str]         List of file names to filter from results.       Required implemented methods     ----------------------------     @classmethod     def get_class_name(cls, module: ModuleType) -> str:         Prefer to use with dir(module)       Available additional methods to overload     ----------------------------------------     @classmethod     def get_class_key(cls, class_: object) -> Hashable:         This value used to define key in our dictionary         Default: class_.__class__.__name__     """      modules_dir: Path      parent_package: str      filter_files: list[str]      @classmethod     def get(cls, name: str) -> T:         """         Get class instance by class_name|key          Arguments         name: str             A class name or a key, if defined by get_class_key-method          Return         Instance of class          Exceptions         ModuleNotFoundError             Raises if module with given name was not found...         """          debug_logger.debug(f"Initialisation for: {name}")          # Get class-object by it's name         class_: CallableClass | None = cls.__get_classes_dict().get(name, None)          if not class_:             e = ModuleNotFoundError(f"Module with given name - {name} - not found!")             debug_logger.exception(e)             raise e          return class_      @classmethod     def exists(cls, name: str) -> bool:         """         Check if class with class_name|key exists in Factory.         It's handy method if you do not want to catch exception of get-method.         """          class_: CallableClass | None = cls.__get_classes_dict().get(name, None)          return class_ is not None      @classmethod     @cache     def __get_classes_dict(cls) -> dict[Hashable, CallableClass]:         """Get cached dictionary of all available classes by Factory"""          classes_dict: dict[Hashable, CallableClass] = {}          # Get all modules path in modules_dir folder         for module_path in os.listdir(cls.modules_dir):             # Filter unused, standard and all other modules,             # which contains in our filter_files             if module_path.endswith(".py") and module_path not in cls.filter_files:                 module: ModuleType = importlib.import_module(                     ".%s" % module_path.removesuffix(".py"),                     package=cls.parent_package,                 )                  # Get class_name by filtering all dir(module) data                 class_name = cls.get_class_name(module)                  class_ = getattr(module, class_name)                 classes_dict[cls.get_class_key(class_)] = class_          return classes_dict      @classmethod     @abstractmethod     def get_class_name(cls, module: ModuleType) -> str:         """         *In implementation of this method, I offer to use dir(module)*         This method must return only name of the desired callable class.          The reason behind this approach:         All data got from dir(module) will have link to all of class Parents,         methods, variables and etc., which contains in module,         because of that, we need to carefully filter result.         """          ...      @classmethod     def get_class_key(cls, class_: object) -> Hashable:         """This value used to define key in our dictionary"""          return class_.__class__.__name__ 

Пример класса-наследника

class ParsersFactory(AbstractFactory[BaseParser]):     modules_dir = Path(__file__).parent / "modules"     parent_package = "src.parsers.modules"      filter_files = ["__init__.py", "base.py"]      @classmethod     def get_class_name(cls, module: ModuleType):         return next(             filter(                 lambda x: x.endswith("Parser") and x != "BaseParser",                 dir(module),             )         )          @classmethod     def get_class_key(cls, class_: object) -> str:         return getattr(class_, "domain")