splent-framework 1.6.2__tar.gz → 1.7.0__tar.gz

{splent_framework-1.6.2/src/splent_framework.egg-info → splent_framework-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_framework
-Version: 1.6.2
+Version: 1.7.0
 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

{splent_framework-1.6.2 → splent_framework-1.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_framework"
-version = "1.6.2"
+version = "1.7.0"
 description = "SPLENT-FRAMEWORK is a set of libraries for agile product development within SPLENT."
 readme = "README.md"
 requires-python = ">=3.13"

splent_framework-1.7.0/src/splent_framework/admin/__init__.py

@@ -0,0 +1,29 @@
+"""Admin resource registry — declare how models surface in the admin panel.
+
+A content feature registers its model with :func:`register_admin_resource`
+(typically from ``init_feature``); the ``admin`` feature reads the registry to
+build a grouped, wp-admin-style menu and CRUD screens. Mirrors the singleton
+pattern of ``splent_framework.hooks.template_hooks``.
+"""
+
+from splent_framework.admin.registry import (
+    WIDGETS,
+    AdminResource,
+    clear_admin_resources,
+    get_admin_groups,
+    get_admin_resource,
+    get_admin_resource_for_model,
+    get_admin_resources,
+    register_admin_resource,
+)
+
+__all__ = [
+    "WIDGETS",
+    "AdminResource",
+    "register_admin_resource",
+    "get_admin_resource",
+    "get_admin_resource_for_model",
+    "get_admin_resources",
+    "get_admin_groups",
+    "clear_admin_resources",
+]

splent_framework-1.7.0/src/splent_framework/admin/registry.py

@@ -0,0 +1,149 @@
+# splent_framework/admin/registry.py
+#
+# Admin resource registry — the analogue of WordPress `register_post_type`.
+#
+# A content feature registers its model as an *admin resource*, declaring how it
+# should appear in the admin panel (label, icon, menu group, list columns,
+# per-field widgets). The `admin` feature reads this registry to build a curated,
+# grouped, wp-admin-style menu and CRUD screens — instead of dumping every
+# `db.Model` subclass in a flat list.
+#
+# NOTE: _resources is a module-level registry populated once at app startup
+# (during feature registration / init_feature) and read-only during request
+# handling — same contract as template_hooks.py. Not thread-safe for concurrent
+# writes; do not call register_admin_resource() from request handlers.
+
+from dataclasses import dataclass, field
+
+# Widget hints the admin form renderer understands. Features may pass any of
+# these per column via `field_widgets`; unknown columns fall back to an
+# introspection-derived default chosen by the admin feature.
+WIDGETS = (
+    "text",  # single-line string
+    "textarea",  # multi-line plain text
+    "richtext",  # WYSIWYG / HTML body
+    "number",
+    "bool",
+    "date",
+    "datetime",
+    "select",  # enum / fixed choices
+    "fk",  # foreign key -> related record picker
+    "image",  # media id / upload
+    "url",
+    "slug",
+    "color",
+)
+
+
+@dataclass
+class AdminResource:
+    """Metadata describing how a model is administered in the admin panel."""
+
+    model: type
+    name: str  # url-safe key, e.g. "project"
+    label: str  # singular human label, e.g. "Project"
+    label_plural: str  # e.g. "Projects"
+    icon: str = "file"  # feather icon name used in the menu
+    group: str = "Content"  # menu section this resource is filed under
+    order: int = 100  # sort order within the group
+    list_columns: list[str] | None = None  # None -> admin auto-picks
+    search_fields: list[str] = field(default_factory=list)
+    field_widgets: dict[str, str] = field(default_factory=dict)  # column -> WIDGETS
+    readonly_fields: list[str] = field(default_factory=list)
+    scope: dict = field(default_factory=dict)  # query filter — lets one shared
+    #                                                      table back several menu entries
+    #                                                      (e.g. {"collection": "event"})
+    create_defaults: dict = field(
+        default_factory=dict
+    )  # column values forced on create
+    feature: str | None = None  # owning feature short name (provenance)
+
+    @property
+    def model_name(self) -> str:
+        """The SQLAlchemy class name — the key the CRUD routes resolve by."""
+        return self.model.__name__
+
+
+# Module-level singleton registry (keyed by resource `name`).
+_resources: dict[str, AdminResource] = {}
+
+
+def register_admin_resource(
+    model: type,
+    *,
+    name: str | None = None,
+    label: str | None = None,
+    label_plural: str | None = None,
+    icon: str = "file",
+    group: str = "Content",
+    order: int = 100,
+    list_columns: list[str] | None = None,
+    search_fields: list[str] | None = None,
+    field_widgets: dict[str, str] | None = None,
+    readonly_fields: list[str] | None = None,
+    scope: dict | None = None,
+    create_defaults: dict | None = None,
+    feature: str | None = None,
+) -> AdminResource:
+    """Register a model as an administered resource (additive, idempotent by name).
+
+    Call from a feature's ``init_feature(app)``. The owning content feature thus
+    declares its admin surface once; the admin panel renders it. Re-registering
+    the same ``name`` overrides the previous entry (last registration wins), which
+    lets a refinement feature curate another feature's resource.
+    """
+    key = name or model.__name__.lower()
+    resolved_label = label or model.__name__
+    res = AdminResource(
+        model=model,
+        name=key,
+        label=resolved_label,
+        label_plural=label_plural or f"{resolved_label}s",
+        icon=icon,
+        group=group,
+        order=order,
+        list_columns=list_columns,
+        search_fields=search_fields or [],
+        field_widgets=field_widgets or {},
+        readonly_fields=readonly_fields or [],
+        scope=scope or {},
+        create_defaults=create_defaults or {},
+        feature=feature,
+    )
+    _resources[key] = res
+    return res
+
+
+def get_admin_resource(name: str) -> AdminResource | None:
+    """Return a single registered resource by its url-safe name, or None."""
+    return _resources.get(name)
+
+
+def get_admin_resource_for_model(model_name: str) -> AdminResource | None:
+    """Return the resource whose model class name matches ``model_name``."""
+    for res in _resources.values():
+        if res.model_name == model_name:
+            return res
+    return None
+
+
+def get_admin_resources() -> dict[str, AdminResource]:
+    """Return all registered resources keyed by name (insertion order)."""
+    return dict(_resources)
+
+
+def get_admin_groups() -> dict[str, list[AdminResource]]:
+    """Return resources bucketed by menu group, each sorted by (order, label).
+
+    This is what the admin sidebar iterates to render a grouped, wp-admin-style
+    menu (a section per group, content types listed underneath).
+    """
+    groups: dict[str, list[AdminResource]] = {}
+    for res in sorted(_resources.values(), key=lambda r: (r.order, r.label)):
+        groups.setdefault(res.group, []).append(res)
+    return groups
+
+
+def clear_admin_resources() -> None:
+    """Remove all registered resources. Intended for test teardown."""
+    _resources.clear()

splent_framework-1.7.0/src/splent_framework/assets/asset_registry.py

@@ -0,0 +1,68 @@
+# splent_framework/assets/asset_registry.py
+#
+# SPL asset registry. Features DECLARE their stylesheets/scripts here (from
+# init_feature) instead of hand-writing <link>/<script> tags in hooks or
+# inlining JS into templates. The public shell renders get_assets("css") in
+# <head> and get_assets("js") before </body>, DEDUPLICATED and ORDERED — so the
+# cascade is deterministic and asset injection is consistent across features.
+# No ad-hoc tags, no inline scripts: a feature ships a file under its blueprint's
+# assets/ folder (served by the blueprint asset route) and registers it here.
+#
+# Cleared per app at feature-load (like the nav registry) so each product only
+# emits the assets of ITS installed features. Registration is idempotent.
+
+_assets: list = []
+
+
+def register_asset(kind: str, endpoint: str, order: int = 100, **params) -> None:
+    """Declare a static asset served by a feature blueprint's asset route.
+
+    Args:
+        kind: "css" or "js".
+        endpoint: the blueprint asset endpoint, e.g. "slider.assets".
+        order: load order (lower first) — governs the cascade deterministically.
+            Convention: theme base ~0, features ~100, skins ~200 (win last).
+        **params: url_for params for the asset route, e.g.
+            subfolder="css", filename="slider.css".
+    """
+    key = (kind, endpoint, tuple(sorted(params.items())))
+    for a in _assets:
+        if a["key"] == key:
+            return
+    _assets.append(
+        {
+            "key": key,
+            "kind": kind,
+            "endpoint": endpoint,
+            "params": params,
+            "order": order,
+        }
+    )
+
+
+def get_assets(kind: str) -> list:
+    """Resolved asset URLs of a kind, ordered by (order, endpoint) and deduped.
+
+    url_for is resolved at call time, so invoke this from the template (request
+    context). Assets whose route can't be resolved are skipped, not raised.
+    """
+    from flask import url_for
+
+    seen = set()
+    out = []
+    for a in sorted(_assets, key=lambda x: (x["order"], x["endpoint"])):
+        if a["kind"] != kind:
+            continue
+        try:
+            href = url_for(a["endpoint"], **a["params"])
+        except Exception:
+            continue
+        if href not in seen:
+            seen.add(href)
+            out.append(href)
+    return out
+
+
+def clear_assets() -> None:
+    """Drop all registered assets. Called per app before feature load."""
+    _assets.clear()

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

@@ -0,0 +1,43 @@
+# 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.
+
+# Each slot holds (order, func) pairs; get_template_hooks returns the funcs
+# sorted by order (lower first), so slots like "home.section" compose features
+# in a deterministic order regardless of feature load order.
+_hooks: dict[str, list] = {}
+
+
+def register_template_hook(name: str, func, order: int = 100) -> None:
+    """Append a callback to a named hook slot (additive).
+
+    order: lower renders first within the slot (default 100).
+    """
+    _hooks.setdefault(name, []).append((order, func))
+
+
+def replace_template_hook(name: str, func, order: int = 100) -> None:
+    """Replace ALL existing callbacks for a named hook slot.
+
+    Used by refinement features to override a base feature's hook content.
+    """
+    _hooks[name] = [(order, func)]
+
+
+def remove_template_hook(name: str, func) -> None:
+    """Remove a specific callback from a hook slot."""
+    if name in _hooks:
+        _hooks[name] = [(o, f) for (o, f) in _hooks[name] if f is not func]
+
+
+def get_template_hooks(name: str) -> list:
+    """Callbacks for a slot, ordered by their registration `order`."""
+    return [f for _, f in sorted(_hooks.get(name, []), key=lambda pair: pair[0])]
+
+
+def clear_hooks() -> None:
+    """Remove all registered hooks. Intended for use in test teardown."""
+    _hooks.clear()

{splent_framework-1.6.2 → splent_framework-1.7.0}/src/splent_framework/managers/feature_loader.py

@@ -248,6 +248,7 @@ class FeatureIntegrator:
         self._call_init(module, import_name)
         self._apply_service_overrides(import_name)
         self._register_blueprints(module, import_name)
+        self._register_context_vars(module, import_name)
         self._register_translations(module, import_name)
         self._register_commands(import_name)
 
@@ -358,6 +359,19 @@ class FeatureIntegrator:
         elif self._strict:
             raise FeatureError(f"{import_name} lacks init_feature(app)")
 
+    def _register_context_vars(self, module, import_name: str) -> None:
+        """Collect the feature's ``inject_context_vars`` so the JinjaManager
+        context processor merges its returned dict into every template's context
+        on each request (see docs: framework/template-system, framework/
+        feature-loading). Without this the function is never called.
+        """
+        fn = getattr(module, "inject_context_vars", None)
+        if fn is None:
+            return
+        if not hasattr(self._app, "context_processors"):
+            self._app.context_processors = []
+        self._app.context_processors.append(fn)
+
     def _register_blueprints(self, module, import_name: str) -> None:
         candidates = self._collect_candidate_modules(module, import_name)
         registered = sum(

{splent_framework-1.6.2 → splent_framework-1.7.0}/src/splent_framework/managers/feature_manager.py

@@ -62,6 +62,18 @@ class FeatureManager:
             return
         self._registered = True
 
+        # The nav and asset registries are process-global; clear them before
+        # loading so the composed menu / injected assets reflect ONLY this
+        # product's installed features (no leakage when several products'
+        # create_app() run in one interpreter).
+        from splent_framework.assets.asset_registry import clear_assets
+        from splent_framework.nav.nav_registry import clear_nav_items
+        from splent_framework.settings.settings_schema import clear_settings_schemas
+
+        clear_nav_items()
+        clear_assets()
+        clear_settings_schemas()
+
         splent_app = self._require_splent_app()
         product_dir = os.path.join(PathUtils.get_working_dir(), splent_app)
 
@@ -121,27 +133,33 @@ class FeatureManager:
     # ------------------------------------------------------------------
 
     def _apply_template_overrides(self, registry) -> None:
-        """Reorder Jinja blueprint template loaders so refiner templates win.
+        """Make refiner templates win over the base feature's same-path templates.
 
-        Flask's DispatchingJinjaLoader searches blueprints in registration order.
-        Since refiners load AFTER their base, their templates would normally lose.
-        We swap the refiner's blueprint ahead of the base's in the internal list.
+        Flask's DispatchingJinjaLoader searches blueprints in REGISTRATION order
+        (first registered wins), and a refiner loads AFTER its base — so the base
+        template would win. We prepend each refiner's template folder to the
+        app's Jinja loader so its override is resolved first.
         """
+        from jinja2 import ChoiceLoader, FileSystemLoader
+
         template_overrides = [
             e for e in registry.all_entries() if e.category == "template"
         ]
         if not template_overrides:
             return
 
+        app = self._app
+        folders: list[str] = []
+        seen: set[str] = set()
         for entry in template_overrides:
-            # Find the refiner's blueprint (convention: refiner registers its own bp)
-            # The refiner's templates are served from its own blueprint template folder.
-            # We need its blueprint to appear BEFORE the base's in the search order.
-            # Flask 3.x uses app.blueprints (ordered dict), and the
-            # DispatchingJinjaLoader iterates app.iter_blueprints() which
-            # returns them in reverse registration order (last registered = first searched).
-            # So the refiner, being loaded after the base, is already searched first.
-            # This means template override works out of the box for same-path templates.
+            short = entry.refiner.replace("splent_feature_", "")
+            bp = app.blueprints.get(short)
+            if bp is None or not bp.template_folder:
+                continue
+            folder = os.path.join(bp.root_path, bp.template_folder)
+            if folder not in seen and os.path.isdir(folder):
+                seen.add(folder)
+                folders.append(folder)
             logger.info(
                 "Template override: %s (from %s, by %s)",
                 entry.target,
@@ -149,6 +167,11 @@ class FeatureManager:
                 entry.refiner,
             )
 
+        if folders:
+            app.jinja_env.loader = ChoiceLoader(
+                [FileSystemLoader(folders), app.jinja_env.loader]
+            )
+
     def _setup_refinement_registry(self, product_dir: str, ordered: list[str]) -> None:
         """Read extensible/refinement declarations from feature pyproject files,
         validate them, and populate the global RefinementRegistry."""

{splent_framework-1.6.2 → splent_framework-1.7.0}/src/splent_framework/managers/jinja_manager.py

@@ -1,4 +1,5 @@
 from flask import Flask
+from splent_framework.assets.asset_registry import get_assets
 from splent_framework.context.context_manager import build_jinja_context
 from splent_framework.hooks.template_hooks import get_template_hooks
 
@@ -17,3 +18,4 @@ class JinjaManager:
 
     def _register_globals(self):
         self.app.jinja_env.globals["get_template_hooks"] = get_template_hooks
+        self.app.jinja_env.globals["get_assets"] = get_assets

{splent_framework-1.6.2 → splent_framework-1.7.0}/src/splent_framework/managers/locale_manager.py

@@ -72,9 +72,15 @@ class LocaleManager:
         if translations_dir not in dirs:
             dirs.append(translations_dir)
 
-            # Babel supports multiple translation directories
-            babel = app.extensions.get("splent_babel")
-            if babel and hasattr(babel, "translation_directories"):
-                babel.translation_directories.append(translations_dir)
+            # flask-babel computes its translation directories ONCE in init_app
+            # (BabelConfiguration.translation_directories) and never re-reads the
+            # config. Features load AFTER Babel is initialised, so we (1) keep the
+            # config in sync and (2) mutate the live BabelConfiguration list
+            # (app.extensions["babel"]) so the new directory actually takes effect.
+            app.config["BABEL_TRANSLATION_DIRECTORIES"] = ";".join(dirs)
+            babel_cfg = app.extensions.get("babel")
+            live = getattr(babel_cfg, "translation_directories", None)
+            if isinstance(live, list) and translations_dir not in live:
+                live.append(translations_dir)
 
             logger.debug("Registered translations: %s", translations_dir)

splent_framework-1.7.0/src/splent_framework/nav/nav_registry.py

@@ -0,0 +1,50 @@
+# splent_framework/nav/nav_registry.py
+#
+# SPL navigation registry. Each CONTENT feature declares its public main-nav
+# entry in init_feature() via register_nav_item(); the menu is therefore
+# *composed from the features actually selected in the product's derivation*,
+# not hardcoded. The theme reads get_nav_items() and layers the admin "Menus"
+# editor's runtime overrides (order / visibility / label) and custom links on
+# top. Remove a feature (re-derive) and its entry disappears on its own; add
+# one and it shows up — that is the SPL variability surfacing in the UI.
+#
+# Populated once at app startup during feature registration; read-only during
+# request handling. Registration is idempotent by key, so a second create_app()
+# (tests, reload) does not duplicate entries. Not thread-safe for writes — do
+# not call register_nav_item() from request handlers.
+
+_nav_items: dict = {}
+
+
+def register_nav_item(
+    key: str, label: str, href: str, order: int = 100, icon=None
+) -> None:
+    """Declare one entry in the public main navigation (opt-in, per feature).
+
+    Args:
+        key: stable identifier (e.g. "projects"); used to reconcile runtime
+            overrides across re-derivations. Unique per feature.
+        label: default human label (translated at render time via gettext).
+        href: public URL/path the entry points to (e.g. "/projects").
+        order: lower sorts first when no runtime override exists.
+        icon: optional feather icon name.
+    """
+    _nav_items[key] = {
+        "key": key,
+        "label": label,
+        "href": href,
+        "order": order,
+        "icon": icon,
+    }
+
+
+def get_nav_items() -> list:
+    """All declared nav entries, sorted by (order, label)."""
+    return sorted(
+        _nav_items.values(), key=lambda i: (i.get("order", 100), i.get("label", ""))
+    )
+
+
+def clear_nav_items() -> None:
+    """Drop all entries. Intended for test teardown."""
+    _nav_items.clear()

splent_framework-1.7.0/src/splent_framework/settings/settings_schema.py

@@ -0,0 +1,103 @@
+# splent_framework/settings/settings_schema.py
+#
+# SPL feature-settings schema registry — the generic way to make any feature
+# that injects UI configurable from the admin.
+#
+# A feature DECLARES its admin-editable settings (a typed schema) via
+# register_settings() in init_feature(). The `settings` feature renders ONE
+# generic admin panel for every declared schema and persists values through
+# SettingsService. No per-feature panel code, no ad-hoc config modules: declare
+# the schema, get a panel + typed reads.
+#
+# Setting keys are namespaced as "<feature>_<field>" automatically, so features
+# never collide. Cleared per app at feature-load (like the nav/asset registries).
+
+_schemas: dict = {}
+
+FIELD_TYPES = ("bool", "int", "text", "color", "select")
+
+
+def register_settings(
+    feature: str, title: str, fields: list, icon: str = "sliders"
+) -> None:
+    """Declare a feature's admin-editable settings.
+
+    Args:
+        feature: stable key, e.g. "slider" (also the panel URL segment and the
+            setting-key namespace).
+        title: human title shown in the panel/sidebar, e.g. "Slider".
+        fields: list of dicts ``{key, type, default, label, help?, options?}``.
+            ``type`` in bool/int/text/color/select. For select, provide
+            ``options`` as a list of ``(value, label)`` pairs.
+        icon: feather icon name for the sidebar entry.
+    """
+    _schemas[feature] = {
+        "feature": feature,
+        "title": title,
+        "icon": icon,
+        "fields": list(fields),
+    }
+
+
+def get_schemas() -> list:
+    """All declared schemas, sorted by title."""
+    return sorted(_schemas.values(), key=lambda s: s["title"].lower())
+
+
+def get_schema(feature: str):
+    return _schemas.get(feature)
+
+
+def clear_settings_schemas() -> None:
+    _schemas.clear()
+
+
+def setting_key(feature: str, field_key: str) -> str:
+    """The namespaced SettingsService key for a feature field."""
+    return f"{feature}_{field_key}"
+
+
+def _cast(field: dict, raw):
+    """Coerce a stored raw string to the field's type, falling back to default."""
+    t = field.get("type")
+    default = field.get("default")
+    if t == "bool":
+        if raw is None:
+            return default in (True, "1", 1)
+        return raw in (True, "1", 1)
+    if t == "int":
+        try:
+            return int(raw)
+        except (TypeError, ValueError):
+            try:
+                return int(default)
+            except (TypeError, ValueError):
+                return 0
+    if t == "color":
+        import re
+
+        if raw and re.match(r"^#[0-9a-fA-F]{3,8}$", raw):
+            return raw
+        return default if default else "#000000"
+    # text / select
+    return raw if raw not in (None, "") else (default if default is not None else "")
+
+
+def get_config(feature: str) -> dict:
+    """Typed current values for a feature's settings, keyed by the SHORT field
+    key (e.g. {"autoplay": True, "interval": 6}). Reads SettingsService and
+    falls back to declared defaults."""
+    from splent_framework.services.service_locator import service_proxy
+
+    schema = _schemas.get(feature)
+    if not schema:
+        return {}
+    try:
+        svc = service_proxy("SettingsService")
+    except Exception:
+        svc = None
+    out = {}
+    for f in schema["fields"]:
+        raw = svc.get(setting_key(feature, f["key"]), None) if svc else None
+        out[f["key"]] = _cast(f, raw)
+    return out

{splent_framework-1.6.2 → splent_framework-1.7.0}/src/splent_framework/signals/signal_utils.py

@@ -20,6 +20,11 @@ logger = logging.getLogger(__name__)
 # Shared blinker namespace for all SPLENT feature signals
 _splent_ns = Namespace()
 
+# Handlers that connected before their producer defined the signal, keyed by
+# signal name. Flushed by define_signal(), so feature load order doesn't matter
+# (a captcha provider can connect to "comment-submitting" before comments loads).
+_pending: dict = {}
+
 
 def define_signal(name: str, provider: str) -> NamedSignal:
     """Define a feature signal and register it in the signal registry.
@@ -39,6 +44,10 @@ def define_signal(name: str, provider: str) -> NamedSignal:
     """
     signal = _splent_ns.signal(name)
     register_signal(name, signal, provider)
+    # Flush handlers that connected before this signal was defined (a listener
+    # feature that loaded before its producer). Load order is now irrelevant.
+    for fn in _pending.pop(name, []):
+        signal.connect(fn)
     return signal
 
 
@@ -62,14 +71,17 @@ def connect_signal(signal_name: str, listener_feature: str):
     """
 
     def decorator(fn):
+        register_listener(signal_name, listener_feature)
         signal = get_signal(signal_name)
         if signal is not None:
             signal.connect(fn)
-            register_listener(signal_name, listener_feature)
         else:
-            logger.warning(
-                "Signal '%s' not found — handler %s.%s not connected. "
-                "Is the provider feature installed?",
+            # Producer not loaded yet (or absent). Defer the connection: if the
+            # producer's define_signal() runs later it flushes this handler. If
+            # the producer is never installed, the handler simply never fires.
+            _pending.setdefault(signal_name, []).append(fn)
+            logger.debug(
+                "Signal '%s' not defined yet — deferring handler %s.%s.",
                 signal_name,
                 fn.__module__,
                 fn.__name__,

{splent_framework-1.6.2 → splent_framework-1.7.0/src/splent_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_framework
-Version: 1.6.2
+Version: 1.7.0
 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

{splent_framework-1.6.2 → splent_framework-1.7.0}/src/splent_framework.egg-info/SOURCES.txt

@@ -9,6 +9,10 @@ src/splent_framework.egg-info/SOURCES.txt
 src/splent_framework.egg-info/dependency_links.txt
 src/splent_framework.egg-info/requires.txt
 src/splent_framework.egg-info/top_level.txt
+src/splent_framework/admin/__init__.py
+src/splent_framework/admin/registry.py
+src/splent_framework/assets/__init__.py
+src/splent_framework/assets/asset_registry.py
 src/splent_framework/blueprints/__init__.py
 src/splent_framework/blueprints/base_blueprint.py
 src/splent_framework/bootstraps/__init__.py
@@ -47,6 +51,8 @@ src/splent_framework/managers/task_queue_manager.py
 src/splent_framework/migrations/__init__.py
 src/splent_framework/migrations/feature_env.py
 src/splent_framework/namespaces/__init__.py
+src/splent_framework/nav/__init__.py
+src/splent_framework/nav/nav_registry.py
 src/splent_framework/refinement/__init__.py
 src/splent_framework/refinement/model_extender.py
 src/splent_framework/refinement/parser.py
@@ -65,6 +71,8 @@ src/splent_framework/serialisers/serializer.py
 src/splent_framework/services/BaseService.py
 src/splent_framework/services/__init__.py
 src/splent_framework/services/service_locator.py
+src/splent_framework/settings/__init__.py
+src/splent_framework/settings/settings_schema.py
 src/splent_framework/signals/__init__.py
 src/splent_framework/signals/registry.py
 src/splent_framework/signals/signal_utils.py

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

@@ -1,36 +0,0 @@
-# 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:
-    """Append a callback to a named hook slot (additive)."""
-    _hooks.setdefault(name, []).append(func)
-
-
-def replace_template_hook(name: str, func) -> None:
-    """Replace ALL existing callbacks for a named hook slot.
-
-    Used by refinement features to override a base feature's hook content.
-    """
-    _hooks[name] = [func]
-
-
-def remove_template_hook(name: str, func) -> None:
-    """Remove a specific callback from a hook slot."""
-    if name in _hooks:
-        _hooks[name] = [f for f in _hooks[name] if f is not 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()