dblift 3.2.1__tar.gz → 3.3.0__tar.gz

{dblift-3.2.1 → dblift-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 3.2.1
+Version: 3.3.0
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

{dblift-3.2.1 → dblift-3.3.0}/core/introspection/_column_enricher.py

@@ -16,7 +16,7 @@ The two helpers take the introspector instance as their first parameter
 from __future__ import annotations
 
 import traceback
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Any, List
 
 if TYPE_CHECKING:
     from core.introspection.schema_introspector import SchemaIntrospector
@@ -253,18 +253,101 @@ def enrich_columns_with_identity(
                     ),
                 }
 
+        # sql_variant columns (e.g. SQL Server's
+        # sys.identity_columns.seed_value/increment_value/last_value) can
+        # arrive via pymssql/FreeTDS as raw on-wire bytes rather than an int
+        # (e.g. the int 1 as b'\x01\x00\x00\x00'). Normalize those to a plain
+        # int here so every downstream consumer -- regardless of which
+        # dialect's driver quirks produced the raw value -- can rely on
+        # identity_seed/identity_increment/identity_last_value already being
+        # an int. Non-bytes values (str, int, None) pass through unchanged,
+        # exactly as before.
+        #
+        # Bytes are only decoded when their length matches a standard
+        # two's-complement integer width (1, 2, 4, or 8 bytes --
+        # tinyint/smallint/int/bigint). SQL Server also permits IDENTITY on
+        # decimal/numeric columns, whose sql_variant wire shape is a sign
+        # byte plus an *unsigned* magnitude -- not a plain two's-complement
+        # integer -- so decoding those the same way would silently produce a
+        # plausible-looking but wrong value. For any other byte length,
+        # refuse to guess and raise instead; the outer try/except around
+        # this whole enrichment pass logs a warning for it.
+        def _decode_sql_variant_int(column_name: str, field_name: str, value: Any) -> Any:
+            if not isinstance(value, bytes):
+                return value
+            if len(value) not in (1, 2, 4, 8):
+                raise ValueError(
+                    f"Column {column_name!r}: {field_name} arrived as "
+                    f"{len(value)} raw bytes, which is not a standard "
+                    f"two's-complement integer width (1, 2, 4, or 8 bytes). "
+                    f"This looks like a non-integer sql_variant encoding "
+                    f"(e.g. decimal/numeric IDENTITY) that isn't supported yet."
+                )
+            return int.from_bytes(value, byteorder="little", signed=True)
+
         # Enrich matching columns with detailed metadata
         for column in columns:
             identity_data = identity_map.get(column.name.upper())
             if identity_data:
-                # Mark as identity (may already be marked from the column query)
+                # Mark as identity (may already be marked from the column
+                # query) for now -- the except block below reverts this if
+                # decoding seed OR increment fails, since a column whose real
+                # identity parameters we can't decode must not still claim
+                # is_identity (see that block for why). last_value is decoded
+                # separately below and its failure does NOT revert this: it
+                # has no downstream DDL consumer, so losing it carries none
+                # of the "silently wrong seed/increment" risk the reset here
+                # exists to guard against.
                 column.is_identity = True
-                # Add detailed metadata
-                column.identity_seed = identity_data["seed_value"]
-                column.identity_increment = identity_data["increment_value"]
-                # Note: last_value is not part of SQL Model, store as custom attribute if needed
-                if identity_data["last_value"] is not None:
-                    column.identity_last_value = identity_data["last_value"]  # type: ignore[attr-defined]
+                # A decode failure (see _decode_sql_variant_int above) is
+                # isolated to THIS column, not the whole table: without this,
+                # one decimal/numeric-typed IDENTITY column sitting alongside
+                # ordinary int-typed ones would raise past this loop into the
+                # table-level except below, silently losing seed/increment/
+                # last_value for every column processed after it too -- a
+                # wider blast radius than the single bad column the raise is
+                # actually about.
+                try:
+                    # Add detailed metadata
+                    column.identity_seed = _decode_sql_variant_int(
+                        column.name, "seed_value", identity_data["seed_value"]
+                    )
+                    column.identity_increment = _decode_sql_variant_int(
+                        column.name, "increment_value", identity_data["increment_value"]
+                    )
+                except ValueError as decode_error:
+                    si.log.warning(
+                        f"Could not decode identity metadata for column "
+                        f"{column.name!r} in {schema}.{table}: {decode_error}"
+                    )
+                    # A decode failure means we cannot reliably tell "seed
+                    # decoded fine, increment failed" apart from "failed
+                    # immediately" -- either way, downstream DDL rendering
+                    # must not mistake a leftover None for "never asked, use
+                    # SQL Server's own default". Reset is_identity and the
+                    # two fields render_identity_clause reads so the column
+                    # falls out of identity handling entirely rather than
+                    # rendering a guessed IDENTITY(1,1).
+                    column.is_identity = False
+                    column.identity_seed = None
+                    column.identity_increment = None
+                else:
+                    # seed/increment decoded fine -- only now attempt
+                    # last_value, in its own try/except so that a
+                    # last_value-only decode failure (e.g. a non-standard
+                    # byte width) doesn't discard the good seed/increment we
+                    # just stored. Note: last_value is not part of SQL Model,
+                    # store as custom attribute if needed.
+                    if identity_data["last_value"] is not None:
+                        try:
+                            column.identity_last_value = _decode_sql_variant_int(  # type: ignore[attr-defined]
+                                column.name, "last_value", identity_data["last_value"]
+                            )
+                        except ValueError as decode_error:
+                            si.log.warning(
+                                f"Could not decode identity metadata for column "
+                                f"{column.name!r} in {schema}.{table}: {decode_error}"
+                            )
 
         if identity_map:
             si.log.debug(

dblift-3.3.0/core/seams/feature_loading.py

@@ -0,0 +1,109 @@
+"""Load ``dblift.features`` entry points (tier feature registration).
+
+Each ``dblift.features`` entry point resolves to a no-arg callable that
+performs registrations against the neutral seams
+(:mod:`core.seams.runtime_checks`, :mod:`core.seams.tier_resolver`, ...).
+OSS ships none; installed higher tiers register their runtime checks and
+tier resolver here.
+
+Loading is idempotent via a module-level once-flag: entry points do not
+change at runtime, and both CLI startup and API-client construction invoke
+:func:`load_feature_extensions`, so double-loading is expected and cheap. An
+empty entry-point result latches immediately unless a known tier
+distribution (``dblift-pro``/``dblift-enterprise``) is installed but its
+entry point hasn't reached this process's metadata view yet, in which case
+it is retried on a later call instead of latched.
+
+``DBLIFT_DISABLE_CLI_EXTENSIONS=1`` skips feature loading entirely. This is
+an accepted, explicit operator opt-out: with higher-tier packages installed
+it also disables their registered runtime checks and tier resolution for
+API usage in the same process.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Callable
+from importlib.metadata import PackageNotFoundError, entry_points, version
+from typing import Protocol
+
+_log = logging.getLogger(__name__)
+
+FEATURE_ENTRY_POINT_GROUP = "dblift.features"
+
+# Feature registrations load in tier order (pro before enterprise, unknown
+# third parties in between, name as the tie-breaker) — the same ordering
+# contract as cli/extensions.py's command-extension loaders.
+_TIER_LOAD_ORDER = {"pro": 0, "enterprise": 2}
+_DEFAULT_TIER_LOAD_ORDER = 1
+
+_features_loaded = False
+
+# Must be updated if a tier package's distribution name changes in the
+# monorepo, or a new tier is added under a different name -- an unlisted
+# distribution is indistinguishable here from "not installed", so
+# _any_tier_distribution_installed silently reverts to the pre-fix
+# never-retries behavior for it.
+_KNOWN_TIER_DISTRIBUTIONS = ("dblift-pro", "dblift-enterprise")
+
+
+def _any_tier_distribution_installed() -> bool:
+    """Whether a known paid-tier package is installed as a distribution.
+
+    Checked independently of whether its ``dblift.features`` entry point has
+    become visible yet in this process's ``importlib.metadata`` view -- this
+    is what distinguishes "no dblift.features entry point will ever exist"
+    (pure OSS, no tier package installed at all -- the ordinary case) from
+    "one exists but hasn't reached this process's view of the metadata yet"
+    (the documented race an empty ``entry_points()`` result alone can't
+    rule out).
+    """
+    for name in _KNOWN_TIER_DISTRIBUTIONS:
+        try:
+            version(name)
+        except PackageNotFoundError:
+            continue
+        except Exception as exc:  # a broken distribution must not break startup
+            _log.warning("Could not check whether %r is installed: %s", name, exc)
+            continue
+        return True
+    return False
+
+
+class _FeatureEntryPoint(Protocol):
+    name: str
+
+    def load(self) -> Callable[[], object]:
+        pass
+
+
+def load_feature_extensions() -> None:
+    """Load every ``dblift.features`` entry point (idempotent, best-effort)."""
+    global _features_loaded
+    if _features_loaded or os.environ.get("DBLIFT_DISABLE_CLI_EXTENSIONS") == "1":
+        return
+    discovered_by_name: dict[str, _FeatureEntryPoint] = {
+        entry_point.name: entry_point
+        for entry_point in entry_points(group=FEATURE_ENTRY_POINT_GROUP)
+    }
+    ordered = sorted(
+        discovered_by_name.values(),
+        key=lambda ep: (_TIER_LOAD_ORDER.get(ep.name, _DEFAULT_TIER_LOAD_ORDER), ep.name),
+    )
+    for entry_point in ordered:
+        try:
+            register = entry_point.load()
+            register()
+        except Exception as exc:  # a bad plugin must not break startup
+            _log.warning("dblift.features '%s' failed to load: %s", entry_point.name, exc)
+    # Latch when something was actually found, OR when nothing was found but
+    # no tier package is installed at all -- an empty result is only the
+    # documented race (a paid package's dblift.features entry point not yet
+    # reaching this process's importlib.metadata view, needing a retry on a
+    # later call, exactly like the identical latch bug fixed in
+    # AlterGeneratorFactory._ensure_populated) when a tier distribution is
+    # actually installed. In pure OSS, with no tier package installed,
+    # OSS's own pyproject.toml declares the entry-points group empty, so an
+    # empty result is permanent and must latch immediately.
+    _features_loaded = bool(ordered) or not _any_tier_distribution_installed()

{dblift-3.2.1 → dblift-3.3.0}/core/sql_generator/alter/alter_generator_factory.py

@@ -46,7 +46,8 @@ class AlterGeneratorFactory:
         load_feature_extensions()
         attach_registered_sql_generators()
         ProviderRegistry.discover_plugins()
-        for plugin_info in ProviderRegistry.list_plugins():
+        plugin_list = ProviderRegistry.list_plugins()
+        for plugin_info in plugin_list:
             # Per-plugin fault isolation: a broken plugin must not
             # prevent the others from registering. (PR #241 Bugbot.)
             try:
@@ -62,7 +63,14 @@ class AlterGeneratorFactory:
                     plugin_info.name,
                     exc,
                 )
-        cls._populated = True
+        # Latch only when plugin discovery itself found something. An empty
+        # ``plugin_list`` is the documented race (entry points not yet wired
+        # up in this process) and must be retried on a later call. A
+        # non-empty ``plugin_list`` means discovery genuinely completed --
+        # even if every plugin's quirks raised or returned no ALTER
+        # generator class, that is a real, stable outcome and should latch
+        # rather than re-running full discovery on every subsequent call.
+        cls._populated = bool(plugin_list)
 
     @classmethod
     def create_generator(cls, dialect: str) -> BaseAlterGenerator:

{dblift-3.2.1 → dblift-3.3.0}/db/base_quirks.py

@@ -435,9 +435,15 @@ class BaseQuirks:
     #: Oracle requires ``FROM DUAL``.
     connection_probe_sql: str = "SELECT 1"
     #: ``SELECT … LIMIT N`` syntax is supported. PostgreSQL, MySQL and
-    #: SQLite accept ``LIMIT``; Oracle (``FETCH FIRST N ROWS ONLY``)
-    #: and DB2 (``FETCH FIRST N ROWS ONLY``) do not; SQL Server uses
-    #: ``TOP N`` instead. When False, post-commit verification queries
+    #: SQLite accept ``LIMIT``; Oracle (``FETCH FIRST N ROWS ONLY``) does
+    #: not; SQL Server uses ``TOP N`` instead. DB2's *preferred* rendering
+    #: is also ``FETCH FIRST N ROWS ONLY`` (see :attr:`row_limit_style`),
+    #: but DB2 additionally accepts a bare trailing ``LIMIT`` clause —
+    #: verified against a live db2 12.01.0500 server via the
+    #: capability-probe integration test
+    #: (``tests/integration/capabilities/test_engine_capabilities.py``) —
+    #: so it sets this True even though its declared ``row_limit_style``
+    #: is not ``"limit"``. When False, post-commit verification queries
     #: and similar probes omit the ``LIMIT`` clause.
     select_supports_limit: bool = True
     #: How a SELECT is bounded to N rows. One of:
@@ -461,12 +467,16 @@ class BaseQuirks:
     #: Read through :meth:`row_limit_clauses`, which renders the triple
     #: rather than making each caller re-derive the syntax. Distinct from
     #: :attr:`select_supports_limit`, which answers the coarser "may I
-    #: append ``LIMIT`` at all" question for optional probes — but the two
-    #: overlap in practice: every dialect that sets a non-default
-    #: ``row_limit_style`` (SQL Server, Oracle, DB2) also sets
-    #: ``select_supports_limit = False``, because none of them accept a bare
-    #: trailing ``LIMIT`` either. Nothing in the framework enforces that the
-    #: two stay consistent, so a new dialect could set one without the other;
+    #: append ``LIMIT`` at all" question for optional probes — the two
+    #: usually correlate (SQL Server and Oracle, which set a non-default
+    #: ``row_limit_style``, also set ``select_supports_limit = False``,
+    #: since neither accepts a bare trailing ``LIMIT``) but they are NOT
+    #: guaranteed to: DB2 is a documented exception — it declares
+    #: ``row_limit_style = "fetch_first"`` as its preferred rendering yet
+    #: sets ``select_supports_limit = True`` because the live engine also
+    #: accepts a bare trailing ``LIMIT`` (verified via the capability-probe
+    #: integration test). Nothing in the framework enforces that the two
+    #: stay consistent, so a new dialect could set one without the other;
     #: see the invariant test in ``tests/unit/db/test_dialect_capability_quirks.py``.
     row_limit_style: str = "limit"
     #: How an "insert or update on primary-key conflict" is expressed.

{dblift-3.2.1 → dblift-3.3.0}/db/plugins/cosmosdb/cosmosdb/query_executor.py

@@ -3,12 +3,15 @@ Cosmos DB query execution using the SQL API.
 
 The Cosmos DB SQL API is a read-only query language: this module runs
 ``SELECT`` against containers. Everything that changes state — containers,
-documents, throughput, indexing policy, TTL — is an Azure SDK call made
-from a Python migration, not SQL routed through a translator.
+documents, throughput, indexing policy, TTL — is an Azure SDK call, not SQL
+routed through a translator. That SDK call is made either from a
+user-authored Python migration (via ``context.db`` / ``context.raw_client``)
+or, for internal callers that are not a migration, through a native escape
+hatch exposed here (e.g. ``upsert_native_item``).
 """
 
 import re
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, cast
 
 from core.exceptions import NoSqlWriteNotSupportedError
 from core.logger import Log, NullLog
@@ -63,8 +66,11 @@ class CosmosDbQueryExecutor(BaseQueryExecutor):
         The Cosmos DB SQL API reads; it does not write. Containers and
         documents are changed through the Azure SDK, so a write statement
         reaching here is a mistake to surface rather than something to
-        translate. Python migrations get to the SDK through
-        ``context.db`` / ``context.raw_client``.
+        translate. User-authored Python migrations get to the SDK through
+        ``context.db`` / ``context.raw_client``; internal, non-migration
+        callers that need to write a single document use
+        :meth:`upsert_native_item` instead of building SQL for this method
+        to reject.
 
         Returns the number of rows a read produced (``0`` for the scalar
         liveness probe).
@@ -168,6 +174,51 @@ class CosmosDbQueryExecutor(BaseQueryExecutor):
             self.log.error(error_msg)
             raise
 
+    def upsert_native_item(self, container_name: str, document: Dict[str, Any]) -> Dict[str, Any]:
+        """Upsert a document directly through the Azure SDK, bypassing SQL.
+
+        ``execute_statement`` only accepts ``SELECT`` — the Cosmos DB SQL API
+        is read-only, and pretending otherwise (the pseudo-SQL emulator this
+        module used to have) was actively wrong, which is why the ADR
+        removing pseudo-SQL deleted it. Container *creation* was ported to a
+        native SDK call at the time (see
+        ``CosmosDbProvider.create_snapshot_table_if_not_exists``, which calls
+        ``CosmosDbSchemaOperations.create_container_if_not_exists`` instead of
+        rendering ``CREATE TABLE``), but the matching write for a single
+        document was missed: an internal caller such as the schema-snapshot
+        repository still built a plain SQL ``INSERT`` and routed it through
+        ``execute_statement``, which now raises
+        ``NoSqlWriteNotSupportedError`` for anything but a ``SELECT``. That
+        exception is swallowed by a best-effort event listener, so
+        ``migrate`` reports success while the snapshot document silently
+        never lands.
+
+        This method provides the native, non-SQL escape hatch a caller needs
+        to close that gap: it calls ``azure.cosmos.ContainerProxy.upsert_item``
+        directly instead of rendering anything this executor — or its
+        SELECT-only ``execute_statement`` — would have to parse as SQL. It is
+        meant for internal dblift callers that hold a provider/query-executor
+        reference and are not a user-authored migration; migrations already
+        reach the SDK through ``context.db`` / ``context.raw_client`` (see
+        ``execute_statement``'s docstring). This change adds the primitive
+        only — the schema-snapshot repository still needs to be updated, in
+        the sibling monorepo where it lives, to call this instead of
+        building an ``INSERT``; until that happens the gap above is not yet
+        closed end-to-end.
+
+        Args:
+            container_name: Name of the Cosmos DB container to upsert into.
+            document: The full document body to upsert. Must include
+                whatever field the container's partition key path points at.
+
+        Returns:
+            The document as returned by the SDK (typically the input body
+            plus Cosmos-assigned system properties such as ``_etag``,
+            ``_ts``, ``_self``).
+        """
+        container_client = self.connection_manager.get_container_client(container_name)
+        return cast(Dict[str, Any], container_client.upsert_item(body=document))
+
     def _normalize_cosmos_sql(self, sql: str, container_name: str) -> str:
         """Normalize Cosmos DB SQL query to use proper container alias.
 

{dblift-3.2.1 → dblift-3.3.0}/db/plugins/cosmosdb/provider.py

@@ -75,6 +75,28 @@ class CosmosDbProvider(NativeProvider):
         connection = self._get_connection_or_raise()
         return self.query_executor.execute_query(connection, sql, params)
 
+    def upsert_native_item(self, container_name: str, document: Dict[str, Any]) -> Dict[str, Any]:
+        """Upsert a document straight through the Azure SDK, bypassing SQL.
+
+        Thin forward to :meth:`CosmosDbQueryExecutor.upsert_native_item` —
+        the same shape as :meth:`execute_statement` and :meth:`execute_query`
+        above, which forward to the query executor's SQL-shaped methods. This
+        one exists for callers (e.g. the schema-snapshot repository) that
+        need to write a single document and hold a provider reference rather
+        than a query-executor one; see
+        :meth:`CosmosDbQueryExecutor.upsert_native_item` for why a native
+        write path exists instead of routing an ``INSERT`` through
+        ``execute_statement``.
+
+        No connection guard here (unlike ``execute_statement`` /
+        ``execute_query``): the query executor reaches the container through
+        ``connection_manager.get_container_client`` rather than the
+        ``connection`` object, the same reason
+        ``create_snapshot_table_if_not_exists`` below calls into
+        ``schema_operations`` directly without fetching one.
+        """
+        return self.query_executor.upsert_native_item(container_name, document)
+
     def create_schema_if_not_exists(self, schema: str) -> None:
         """Create schema if it doesn't exist (Cosmos DB doesn't have schemas)."""
         connection = self._get_connection_or_raise()

{dblift-3.2.1 → dblift-3.3.0}/db/plugins/db2/quirks.py

@@ -72,8 +72,10 @@ class Db2Quirks(BaseQuirks):
         return self.is_data_history_table_already_exists_error(error_message)
 
     connection_probe_sql = "SELECT 1 FROM SYSIBM.SYSDUMMY1"
-    select_supports_limit = False
-    # Trailing ``FETCH FIRST n ROWS ONLY``; no ``LIMIT``.
+    select_supports_limit = True
+    # Canonical rendering is trailing ``FETCH FIRST n ROWS ONLY``, but DB2
+    # also accepts a bare trailing ``LIMIT n`` (verified against a live
+    # db2 12.01.0500 server via the capability-probe integration test).
     row_limit_style = "fetch_first"
     unquoted_identifier_case = "uppercase"
     connection_identifier_attrs = ("url", "host", "database")

{dblift-3.2.1 → dblift-3.3.0}/dblift.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 3.2.1
+Version: 3.3.0
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

{dblift-3.2.1 → dblift-3.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dblift"
-version = "3.2.1"
+version = "3.3.0"
 description = "A database migration tool that supports multiple databases with native Python drivers"
 readme = "README.md"
 requires-python = ">=3.11"

dblift-3.2.1/core/seams/feature_loading.py

@@ -1,66 +0,0 @@
-"""Load ``dblift.features`` entry points (tier feature registration).
-
-Each ``dblift.features`` entry point resolves to a no-arg callable that
-performs registrations against the neutral seams
-(:mod:`core.seams.runtime_checks`, :mod:`core.seams.tier_resolver`, ...).
-OSS ships none; installed higher tiers register their runtime checks and
-tier resolver here.
-
-Loading is idempotent via a module-level once-flag: entry points do not
-change at runtime, and both CLI startup and API-client construction invoke
-:func:`load_feature_extensions`, so double-loading is expected and cheap.
-
-``DBLIFT_DISABLE_CLI_EXTENSIONS=1`` skips feature loading entirely. This is
-an accepted, explicit operator opt-out: with higher-tier packages installed
-it also disables their registered runtime checks and tier resolution for
-API usage in the same process.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-from collections.abc import Callable
-from importlib.metadata import entry_points
-from typing import Protocol
-
-_log = logging.getLogger(__name__)
-
-FEATURE_ENTRY_POINT_GROUP = "dblift.features"
-
-# Feature registrations load in tier order (pro before enterprise, unknown
-# third parties in between, name as the tie-breaker) — the same ordering
-# contract as cli/extensions.py's command-extension loaders.
-_TIER_LOAD_ORDER = {"pro": 0, "enterprise": 2}
-_DEFAULT_TIER_LOAD_ORDER = 1
-
-_features_loaded = False
-
-
-class _FeatureEntryPoint(Protocol):
-    name: str
-
-    def load(self) -> Callable[[], object]:
-        pass
-
-
-def load_feature_extensions() -> None:
-    """Load every ``dblift.features`` entry point (idempotent, best-effort)."""
-    global _features_loaded
-    if _features_loaded or os.environ.get("DBLIFT_DISABLE_CLI_EXTENSIONS") == "1":
-        return
-    discovered_by_name: dict[str, _FeatureEntryPoint] = {
-        entry_point.name: entry_point
-        for entry_point in entry_points(group=FEATURE_ENTRY_POINT_GROUP)
-    }
-    ordered = sorted(
-        discovered_by_name.values(),
-        key=lambda ep: (_TIER_LOAD_ORDER.get(ep.name, _DEFAULT_TIER_LOAD_ORDER), ep.name),
-    )
-    for entry_point in ordered:
-        try:
-            register = entry_point.load()
-            register()
-        except Exception as exc:  # a bad plugin must not break startup
-            _log.warning("dblift.features '%s' failed to load: %s", entry_point.name, exc)
-    _features_loaded = True