refactor: Simplify PySpringModelProvider by removing unused methods and enhancing initialization logic for model classes and table creation.

Author: William-W-Chen

py_spring_model/core/commons.py

@@ -23,11 +23,9 @@ class PySpringModelProperties(Properties):
     This class defines properties specific to the PySpring Model, including:
 
     - `__key__`: The key used to identify this set of properties.
-    - `model_file_postfix_patterns`: A set of strings representing file name patterns for model files.
     - `sqlalchemy_database_uri`: The SQLAlchemy database URI used for the model.
     """
 
     __key__ = "py_spring_model"
-    model_file_postfix_patterns: set[str]
     sqlalchemy_database_uri: str
     create_all_tables: bool = True

py_spring_model/py_spring_model_provider.py

@@ -1,21 +1,15 @@
-import inspect
-from typing import Iterable, Type, cast
+from typing import Type, cast
 
-import py_spring_core.core.utils as core_utils
 from loguru import logger
 from py_spring_core import Component, EntityProvider, ApplicationContextRequired
 from sqlalchemy import create_engine
-from sqlalchemy.exc import InvalidRequestError as SqlAlehemyInvalidRequestError
 from sqlmodel import SQLModel
 
-from py_spring_model.core.commons import ApplicationFileGroups, PySpringModelProperties
+from py_spring_model.core.commons import PySpringModelProperties
 from py_spring_model.core.model import PySpringModel
 from py_spring_model.py_spring_model_rest.controller.session_controller import SessionController
 from py_spring_model.repository.repository_base import RepositoryBase
 from py_spring_model.py_spring_model_rest import PySpringModelRestService
-from py_spring_model.py_spring_model_rest.controller.py_spring_model_rest_controller import (
-    PySpringModelRestController,
-)
 from py_spring_model.py_spring_model_rest.service.curd_repository_implementation_service.crud_repository_implementation_service import (
     CrudRepositoryImplementationService,
 )
@@ -43,94 +37,17 @@ def _get_props(self) -> PySpringModelProperties:
         assert props is not None
         return props
 
-    def _group_file_paths(self, files: Iterable[str]) -> ApplicationFileGroups:
-        props = self._get_props()
-
-        class_files: set[str] = set()
-        model_files: set[str] = set()
-
-        for file in files:
-            py_file_name = self._get_file_base_name(file)
-            if py_file_name in props.model_file_postfix_patterns:
-                model_files.add(file)
-            if file not in model_files:
-                class_files.add(file)
-        return ApplicationFileGroups(class_files=class_files, model_files=model_files)
-
-    def _import_model_modules(self) -> None:
-        logger.info(
-            f"[SQLMODEL TABLE MODEL IMPORT] Import all models: {self.app_file_groups.model_files}"
-        )
-
-        def import_func_wrapper() -> set[type[object]]:
-            return core_utils.dynamically_import_modules(
-                self.app_file_groups.model_files,
-                is_ignore_error=False,
-                target_subclasses=[PySpringModel, SQLModel],
-            )
-
-        try:
-            self._model_classes = import_func_wrapper()
-        except SqlAlehemyInvalidRequestError as error:
-            logger.warning(
-                f"[ERROR ADVISE] Encounter {error.__class__.__name__} when importing model classes."
-            )
-            logger.error(
-                f"[SQLMODEL TABLE MODEL IMPORT FAILED] Failed to import model modules: {error}"
-            )
-        self._model_classes = self._get_pyspring_model_inheritors()
-
-    def _is_from_model_file(self, cls: Type[object]) -> bool:
-        props = self._get_props()
-        try:
-            source_file_name = inspect.getsourcefile(cls)
-        except TypeError as error:
-            logger.warning(
-                f"[CHECK MODEL FILE] Failed to get source file name for class: {cls.__name__}, largely due to built-in classes.\n Actual error: {error}"
-            )
-            return False
-        if source_file_name is None:
-            return False
-        py_file_name = self._get_file_base_name(source_file_name)  # e.g., models.py
-        return py_file_name in props.model_file_postfix_patterns
-
-    def _get_file_base_name(self, file_path: str) -> str:
-        return file_path.split("/")[-1]
-
     def _get_pyspring_model_inheritors(self) -> set[Type[object]]:
         # use dict to store all models, use a session to check if all models are mapped
         class_name_with_class_map: dict[str, Type[object]] = {}
         for _cls in set(PySpringModel.__subclasses__()):
             if _cls.__name__ in class_name_with_class_map:
                 continue
-            if not self._is_from_model_file(_cls):
-                logger.warning(
-                    f"[SQLMODEL TABLE MODEL IMPORT] {_cls.__name__} is not from model file, skip it."
-                )
-                continue
-
             class_name_with_class_map[_cls.__name__] = _cls
 
         return set(class_name_with_class_map.values())
-
+    
     def _create_all_tables(self) -> None:
-        props = self._get_props()
-        
-
-        PySpringModel.set_engine(self.sql_engine)
-        PySpringModel.set_models(
-            cast(list[Type[PySpringModel]], list(self._model_classes))
-        )
-        PySpringModel.set_metadata(SQLModel.metadata)
-        RepositoryBase.engine = self.sql_engine
-        RepositoryBase.connection = self.sql_engine.connect()
-
-        if not props.create_all_tables:
-            logger.info("[SQLMODEL TABLE CREATION] Skip creating all tables, set create_all_tables to True to enable.")
-            return
-        if not props.create_all_tables:
-            return
-        
         table_names = SQLModel.metadata.tables.keys()
         logger.success(
             f"[SQLMODEL TABLE CREATION] Create all SQLModel tables, engine url: {self.sql_engine.url}, tables: {', '.join(table_names)}"
@@ -140,18 +57,30 @@ def _create_all_tables(self) -> None:
             f"[SQLMODEL TABLE MODEL IMPORT] Get model classes from PySpringModel inheritors: {', '.join([_cls.__name__ for _cls in self._model_classes])}"
         )
 
+        
+    def _init_pyspring_model(self) -> None:
+        self._model_classes = self._get_pyspring_model_inheritors()
+        PySpringModel.set_engine(self.sql_engine)
+        PySpringModel.set_models(
+            cast(list[Type[PySpringModel]], list(self._model_classes))
+        )
+        PySpringModel.set_metadata(SQLModel.metadata)
+        RepositoryBase.engine = self.sql_engine
+        RepositoryBase.connection = self.sql_engine.connect()
+        
     def provider_init(self) -> None:
         props = self._get_props()
         logger.info(
             f"[PYSPRING MODEL PROVIDER INIT] Initialize PySpringModelProvider with app context: {self.app_context}"
         )
-        app_context = self.get_application_context()
-
-        self.app_file_groups = self._group_file_paths(app_context.all_file_paths)
         self.sql_engine = create_engine(
             url=props.sqlalchemy_database_uri, echo=True
         )
-        self._import_model_modules()
+        self._init_pyspring_model()
+        props = self._get_props()
+        if not props.create_all_tables:
+            logger.info("[SQLMODEL TABLE CREATION] Skip creating all tables, set create_all_tables to True to enable.")
+            return
         self._create_all_tables()