splent-framework 0.0.3__tar.gz → 1.2.5__tar.gz

splent_framework-1.2.5/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: splent_framework
+Version: 1.2.5
+Summary: SPLENT-FRAMEWORK is a set of libraries for agile product development within SPLENT.
+Author-email: DiversoLab <diversolab@us.es>
+Project-URL: Homepage, https://github.com/diverso-lab/splent_framework
+Project-URL: Issues, https://github.com/diverso-lab/splent_framework/issues
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: sqlalchemy==2.0.37
+Requires-Dist: flask==3.1.0
+Requires-Dist: flask_sqlalchemy==3.1.1
+Requires-Dist: flask_migrate==4.1.0
+Requires-Dist: flask_session==0.8.0
+Requires-Dist: flask_mail==0.10.0
+Requires-Dist: flask_login==0.6.3
+Requires-Dist: flask_wtf==1.2.2
+Requires-Dist: redis==5.2.1
+Requires-Dist: pymysql==1.1.1
+Requires-Dist: psutil==6.1.1
+Requires-Dist: pytz==2024.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3; extra == "dev"
+Requires-Dist: pytest-cov>=6.0; extra == "dev"
+Dynamic: license-file
+
+# SPLENT Framework
+
+Core library for building modular, feature-driven Flask applications using Software Product Line principles.
+
+## What it provides
+
+- **Manager pattern** — Pluggable subsystem managers (features, config, migrations, sessions, Jinja, error handling)
+- **Feature system** — Modular features with lifecycle tracking, UVL-based dependency ordering, and per-feature Alembic migrations
+- **Base classes** — `BaseBlueprint`, `BaseRepository`, `BaseService`, `BaseSeeder`, `GenericResource`
+- **App factory** — `create_app()` wires everything together with env-aware feature loading
+
+## Quick start
+
+```python
+from splent_framework.managers.feature_manager import FeatureManager
+
+def create_app(config_name="development"):
+    app = Flask(__name__)
+    # ... config, db, sessions ...
+    FeatureManager(app, strict=False).register_features()
+    return app
+```
+
+## Requirements
+
+- Python 3.13+
+- Flask 3.1+
+- SQLAlchemy 2.0+
+
+## Documentation
+
+Full documentation at **[docs.splent.io](https://docs.splent.io)**
+
+## License
+
+Creative Commons CC BY 4.0 - SPLENT - Diverso Lab

splent_framework-1.2.5/README.md

@@ -0,0 +1,36 @@
+# SPLENT Framework
+
+Core library for building modular, feature-driven Flask applications using Software Product Line principles.
+
+## What it provides
+
+- **Manager pattern** — Pluggable subsystem managers (features, config, migrations, sessions, Jinja, error handling)
+- **Feature system** — Modular features with lifecycle tracking, UVL-based dependency ordering, and per-feature Alembic migrations
+- **Base classes** — `BaseBlueprint`, `BaseRepository`, `BaseService`, `BaseSeeder`, `GenericResource`
+- **App factory** — `create_app()` wires everything together with env-aware feature loading
+
+## Quick start
+
+```python
+from splent_framework.managers.feature_manager import FeatureManager
+
+def create_app(config_name="development"):
+    app = Flask(__name__)
+    # ... config, db, sessions ...
+    FeatureManager(app, strict=False).register_features()
+    return app
+```
+
+## Requirements
+
+- Python 3.13+
+- Flask 3.1+
+- SQLAlchemy 2.0+
+
+## Documentation
+
+Full documentation at **[docs.splent.io](https://docs.splent.io)**
+
+## License
+
+Creative Commons CC BY 4.0 - SPLENT - Diverso Lab

{splent_framework-0.0.3 → splent_framework-1.2.5}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_framework"
-version = "0.0.3"
+version = "1.2.5"
 description = "SPLENT-FRAMEWORK is a set of libraries for agile product development within SPLENT."
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.13"
 authors = [{ name = "DiversoLab", email = "diversolab@us.es" }]
 license-files = ["LICENSE"]
 
@@ -27,12 +27,23 @@ dependencies = [
     "pytz==2024.2"
 ]
 
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3",
+    "pytest-cov>=6.0",
+]
+
 [tool.setuptools]
 package-dir = { "" = "src" }
 
 [tool.setuptools.packages.find]
 where = ["src"]
 
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+filterwarnings = ["ignore::pytest.PytestCollectionWarning"]
+
 [project.urls]
 Homepage = "https://github.com/diverso-lab/splent_framework"
 Issues = "https://github.com/diverso-lab/splent_framework/issues"

splent_framework-1.2.5/src/splent_framework/blueprints/base_blueprint.py

@@ -0,0 +1,87 @@
+# base_blueprint.py
+from flask import Blueprint, Response, abort
+import os
+import sys
+import importlib
+
+
+class BaseBlueprint(Blueprint):
+    def __init__(
+        self,
+        name,
+        import_name,  # typically __name__ of the feature package
+        static_folder=None,
+        static_url_path=None,
+        template_folder=None,
+        url_prefix=None,
+        subdomain=None,
+        url_defaults=None,
+        root_path=None,
+    ):
+        super().__init__(
+            name,
+            import_name,
+            static_folder=static_folder,
+            static_url_path=static_url_path,
+            template_folder=template_folder,
+            url_prefix=url_prefix,
+            subdomain=subdomain,
+            url_defaults=url_defaults,
+            root_path=root_path,
+        )
+
+        # Resolve feature package directory via Python's module system
+        try:
+            module = sys.modules.get(import_name) or importlib.import_module(
+                import_name
+            )
+            pkg_dir = os.path.dirname(module.__file__)
+        except (ImportError, AttributeError) as e:
+            raise RuntimeError(
+                f"Cannot resolve package path for {import_name}: {e}"
+            )
+
+        # Root directory of this feature package (src/splent_io/splent_feature_xxx)
+        self.feature_code_path = pkg_dir
+
+        # Fall back to the feature's own templates/ if none was passed
+        if self.template_folder is None:
+            self.template_folder = os.path.join(self.feature_code_path, "templates")
+
+        self.add_asset_routes()
+
+    def add_asset_routes(self):
+        assets_folder = os.path.join(self.feature_code_path, "assets")
+        if os.path.exists(assets_folder):
+            self.add_url_rule(
+                f"/{self.name}/<path:subfolder>/<path:filename>",
+                "assets",
+                self.send_file,
+            )
+
+    def send_file(self, subfolder, filename):
+        allowed_subfolders = {"js", "css", "dist"}
+        if subfolder not in allowed_subfolders:
+            abort(404)
+
+        base_dir = os.path.realpath(
+            os.path.join(self.feature_code_path, "assets", subfolder)
+        )
+        requested_path = os.path.realpath(os.path.join(base_dir, filename))
+
+        # Prevent path traversal: resolved path must stay inside base_dir
+        if not requested_path.startswith(base_dir + os.sep) and requested_path != base_dir:
+            abort(403)
+
+        if not os.path.isfile(requested_path):
+            abort(404)
+
+        if filename.endswith(".js"):
+            mimetype = "application/javascript"
+        elif filename.endswith(".css"):
+            mimetype = "text/css"
+        else:
+            mimetype = "text/plain"
+
+        with open(requested_path, "r") as f:
+            return Response(f.read(), mimetype=mimetype)

{splent_framework-0.0.3/src/splent_framework/core → splent_framework-1.2.5/src/splent_framework}/bootstraps/locustfile_bootstrap.py

@@ -2,27 +2,30 @@ import os
 import glob
 import inspect
 import importlib.util
+import logging
 from locust import HttpUser
 from dotenv import load_dotenv
 
+logger = logging.getLogger(__name__)
+
 
 def load_locustfiles():
     load_dotenv()
     working_dir = os.getenv("WORKING_DIR", "")
-    print(f"Working directory: {working_dir}")
+    logger.debug("Working directory: %s", working_dir)
 
     module_dir = os.path.join(working_dir, "app", "modules")
-    print(f"Module directory: {module_dir}")
+    logger.debug("Module directory: %s", module_dir)
 
     locustfile_paths = glob.glob(
         os.path.join(module_dir, "*", "tests", "locustfile.py")
     )
-    print(f"Found locustfiles: {locustfile_paths}")
+    logger.debug("Found locustfiles: %s", locustfile_paths)
 
     found_user_classes = []
 
     for path in locustfile_paths:
-        print(f"Loading locustfile: {path}")
+        logger.debug("Loading locustfile: %s", path)
         module_name = os.path.splitext(os.path.basename(path))[0]
         spec = importlib.util.spec_from_file_location(module_name, path)
         locustfile = importlib.util.module_from_spec(spec)
@@ -38,7 +41,7 @@ def load_locustfiles():
                 unique_name = f"{name}_{os.path.basename(path).split('.')[0]}"
                 globals()[unique_name] = obj  # Add to globals
                 found_user_classes.append((unique_name, obj))
-                print(f"Loaded user class: {unique_name}")
+                logger.debug("Loaded user class: %s", unique_name)
 
     if not found_user_classes:
         raise ValueError("No User class found!")
@@ -47,4 +50,4 @@ def load_locustfiles():
 
 
 found_user_classes = load_locustfiles()
-print(f"Total user classes loaded: {len(found_user_classes)}")
+logger.info("Total user classes loaded: %d", len(found_user_classes))

splent_framework-1.2.5/src/splent_framework/configuration/default_config.py

@@ -0,0 +1,56 @@
+import os
+
+
+def _build_db_uri(db_name_env: str, db_name_default: str) -> str:
+    return (
+        f"mysql+pymysql://{os.getenv('MARIADB_USER', 'default_user')}:"
+        f"{os.getenv('MARIADB_PASSWORD', 'default_password')}@"
+        f"{os.getenv('MARIADB_HOSTNAME', 'localhost')}:3306/"
+        f"{os.getenv(db_name_env, db_name_default)}"
+    )
+
+
+class Config:
+    # WARNING: override SECRET_KEY via env var in all non-development environments
+    SECRET_KEY = os.getenv("SECRET_KEY", "dev_test_key_1234567890abcdefghijklmnopqrstu")
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+    TEMPLATES_AUTO_RELOAD = True
+    UPLOAD_FOLDER = "uploads"
+    SESSION_TYPE = "filesystem"
+
+    def __init__(self):
+        # Resolved at instantiation time so runtime env changes are picked up
+        self.TIMEZONE = os.getenv("TIMEZONE", "Europe/Madrid")
+
+
+class DevelopmentConfig(Config):
+    DEBUG = True
+
+    def __init__(self):
+        super().__init__()
+        self.SQLALCHEMY_DATABASE_URI = _build_db_uri("MARIADB_DATABASE", "default_db")
+
+
+class TestingConfig(Config):
+    TESTING = True
+    WTF_CSRF_ENABLED = False
+    SESSION_TYPE = "filesystem"
+    SESSION_FILE_DIR = "/tmp/flask_sessions"
+
+    def __init__(self):
+        super().__init__()
+        self.SQLALCHEMY_DATABASE_URI = _build_db_uri(
+            "MARIADB_TEST_DATABASE", "default_test_db"
+        )
+
+
+class ProductionConfig(Config):
+    DEBUG = False
+
+    def __init__(self):
+        super().__init__()
+        if not os.getenv("SECRET_KEY"):
+            raise RuntimeError(
+                "SECRET_KEY environment variable must be set in production."
+            )
+        self.SQLALCHEMY_DATABASE_URI = _build_db_uri("MARIADB_DATABASE", "default_db")

splent_framework-1.2.5/src/splent_framework/context/context_manager.py

@@ -0,0 +1,26 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def build_jinja_context(app, base_context: dict) -> dict:
+    """
+    Combines the base context with variables injected by feature context processors.
+    """
+    ctx = dict(base_context)  # defensive copy — do not mutate the caller's dict
+
+    for fn in getattr(app, "context_processors", []):
+        try:
+            result = fn(app)
+            if isinstance(result, dict):
+                ctx.update(result)
+            else:
+                logger.warning(
+                    "Feature context processor %s returned %s instead of dict",
+                    fn,
+                    type(result),
+                )
+        except Exception as e:
+            logger.exception("Error in feature context processor %s: %s", fn, e)
+
+    return ctx

splent_framework-1.2.5/src/splent_framework/db.py

@@ -0,0 +1,3 @@
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()

{splent_framework-0.0.3/src/splent_framework/core → splent_framework-1.2.5/src/splent_framework}/decorators/decorators.py

@@ -4,9 +4,7 @@ from flask import abort
 
 
 def pass_or_abort(condition):
-
     def decorator(f):
-
         @wraps(f)
         def decorated_function(*args, **kwargs):
             if not condition(**kwargs):

splent_framework-1.2.5/src/splent_framework/fixtures/fixtures.py

@@ -0,0 +1,69 @@
+import pytest
+from splent_framework.db import db
+from splent_framework.utils.app_loader import get_create_app_in_testing_mode
+
+
+@pytest.fixture(scope="session")
+def test_app():
+    """
+    Creates and initializes the Flask app for the test session.
+    Drops and creates all tables once per session.
+    """
+    app = get_create_app_in_testing_mode()
+    with app.app_context():
+        db.drop_all()
+        db.create_all()
+    yield app
+
+
+@pytest.fixture(scope="function")
+def test_client(test_app):
+    """
+    Provides a test client and resets the DB before and after each test.
+    This ensures test isolation.
+    """
+    with test_app.app_context():
+        db.session.remove()
+        db.drop_all()
+        db.create_all()
+    with test_app.test_client() as client:
+        yield client
+    with test_app.app_context():
+        db.session.remove()
+        db.drop_all()
+        db.create_all()
+
+
+@pytest.fixture(scope="module")
+def test_client_module(test_app):
+    """
+    Shared test client for the entire module.
+    Resets the database only at the start and end of the module.
+    """
+    with test_app.app_context():
+        db.session.remove()
+        db.drop_all()
+        db.create_all()
+
+        with test_app.test_client() as client:
+            yield client
+
+        db.session.remove()
+        db.drop_all()
+        db.create_all()
+
+
+@pytest.fixture(scope="function")
+def clean_database(test_app):
+    """
+    Provides a manual DB reset during a test when needed.
+    Useful if you want to control when the DB is cleaned.
+    """
+    with test_app.app_context():
+        db.session.remove()
+        db.drop_all()
+        db.create_all()
+        yield
+        db.session.remove()
+        db.drop_all()
+        db.create_all()

{splent_framework-0.0.3/src/splent_framework/core → splent_framework-1.2.5/src/splent_framework}/helpers/test_helpers_auth.py

@@ -6,5 +6,6 @@ def login(test_client, email, password):
     )
     return response
 
+
 def logout(test_client):
     return test_client.get("/logout", follow_redirects=True)

{splent_framework-0.0.3/src/splent_framework/core → splent_framework-1.2.5/src/splent_framework}/helpers/test_helpers_db.py

@@ -1,7 +1,6 @@
 import pytest
-from splent_cli.utils.dynamic_imports import get_db
+from splent_framework.db import db
 
-db = get_db()
 
 @pytest.fixture(scope="function")
 def clean_database():

splent_framework-1.2.5/src/splent_framework/hooks/template_hooks.py

@@ -0,0 +1,21 @@
+# splent_framework/template_hooks.py
+#
+# NOTE: _hooks is a module-level registry populated once at app startup
+# (during feature registration) and read-only during request handling.
+# It is NOT thread-safe for concurrent writes; do not call
+# register_template_hook() from request handlers or background threads.
+
+_hooks: dict[str, list] = {}
+
+
+def register_template_hook(name: str, func) -> None:
+    _hooks.setdefault(name, []).append(func)
+
+
+def get_template_hooks(name: str) -> list:
+    return _hooks.get(name, [])
+
+
+def clear_hooks() -> None:
+    """Remove all registered hooks. Intended for use in test teardown."""
+    _hooks.clear()

{splent_framework-0.0.3/src/splent_framework/core → splent_framework-1.2.5/src/splent_framework}/locust/common.py

@@ -1,14 +1,16 @@
+import logging
+
 from faker import Faker
 from bs4 import BeautifulSoup
 
 fake = Faker()
+logger = logging.getLogger(__name__)
 
 
 def get_csrf_token(response):
     soup = BeautifulSoup(response.text, "html.parser")
     token_tag = soup.find("input", {"name": "csrf_token"})
-    if token_tag:
-        return token_tag["value"]
-    else:
-        print("Response HTML:", response.text)
+    if token_tag is None:
+        logger.debug("CSRF token not found. Response HTML: %s", response.text)
         raise ValueError("CSRF token not found in the response")
+    return token_tag["value"]

splent_framework-1.2.5/src/splent_framework/managers/config_manager.py

@@ -0,0 +1,46 @@
+import importlib
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigManager:
+    def __init__(self, app):
+        self.app = app
+
+    @classmethod
+    def init_app(cls, app, config_name="development"):
+        """Factory method to initialize and load configuration."""
+        manager = cls(app)
+        manager.load_config(config_name)
+        return manager
+
+    def load_config(self, config_name: str = "development") -> None:
+        config_name = config_name or os.getenv("FLASK_ENV", "development")
+        splent_app = os.getenv("SPLENT_APP", "splent_app")
+
+        try:
+            config_module = importlib.import_module(f"{splent_app}.config")
+        except ModuleNotFoundError:
+            from splent_framework.configuration import default_config as config_module
+
+            logger.warning("No product config.py found for '%s', using SPLENT default config.", splent_app)
+
+        config_class_name = f"{config_name.capitalize()}Config"
+        config_class = getattr(config_module, config_class_name, None)
+
+        if config_class is None:
+            raise RuntimeError(
+                f"Could not find class '{config_class_name}' in '{splent_app}.config'"
+            )
+
+        config_instance = config_class()
+
+        # Combine instance attributes (set in __init__) with class-level uppercase attrs
+        config_data = {k: v for k, v in config_instance.__dict__.items() if k.isupper()}
+        for k in dir(config_instance):
+            if k.isupper() and k not in config_data:
+                config_data[k] = getattr(config_instance, k)
+
+        self.app.config.from_mapping(config_data)

splent_framework-1.2.5/src/splent_framework/managers/db_manager.py

@@ -0,0 +1,15 @@
+from splent_framework.managers.migration_manager import MigrationManager
+
+
+class MigrateManager(MigrationManager):
+    """
+    Backward-compatible alias for MigrationManager.
+
+    App factories that import MigrateManager continue to work without changes:
+
+        from splent_framework.managers.db_manager import MigrateManager
+        MigrateManager(app)
+
+    All migration logic — including splent_migrations table creation and
+    per-feature migration support — is now in MigrationManager.
+    """

splent_framework-1.2.5/src/splent_framework/managers/error_handler_manager.py

@@ -0,0 +1,60 @@
+import os
+import importlib
+import types
+from collections.abc import Callable
+from flask import render_template
+
+
+class ErrorHandlerManager:
+    def __init__(self, app) -> None:
+        self.app = app
+        self.custom_handlers = self._import_custom_handlers()
+
+    def _import_custom_handlers(self) -> types.ModuleType | None:
+        splent_app = os.getenv("SPLENT_APP", "splent_app")
+        try:
+            return importlib.import_module(f"{splent_app}.errors")
+        except ModuleNotFoundError:
+            return None
+
+    def _get_handler(self, name: str, fallback: Callable) -> Callable:
+        if self.custom_handlers and hasattr(self.custom_handlers, name):
+            return getattr(self.custom_handlers, name)
+        return fallback
+
+    def register_error_handlers(self) -> None:
+        @self.app.errorhandler(500)
+        def internal_error(e):
+            return self._get_handler("handle_500", self._default_500)(self.app, e)
+
+        @self.app.errorhandler(404)
+        def not_found_error(e):
+            return self._get_handler("handle_404", self._default_404)(self.app, e)
+
+        @self.app.errorhandler(401)
+        def unauthorized_error(e):
+            return self._get_handler("handle_401", self._default_401)(self.app, e)
+
+        @self.app.errorhandler(400)
+        def bad_request_error(e):
+            return self._get_handler("handle_400", self._default_400)(self.app, e)
+
+    @staticmethod
+    def _default_500(app, e):
+        app.logger.error("Internal Server Error: %s", str(e))
+        return render_template("500.html"), 500
+
+    @staticmethod
+    def _default_404(app, e):
+        app.logger.warning("Page Not Found: %s", str(e))
+        return render_template("404.html"), 404
+
+    @staticmethod
+    def _default_401(app, e):
+        app.logger.warning("Unauthorized Access: %s", str(e))
+        return render_template("401.html"), 401
+
+    @staticmethod
+    def _default_400(app, e):
+        app.logger.warning("Bad Request: %s", str(e))
+        return render_template("400.html"), 400