sqlbuild 0.67.2__tar.gz → 0.68.0__tar.gz

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/Cargo.lock

@@ -572,7 +572,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.67.2"
+version = "0.68.0"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.67.2
+Version: 0.68.0
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: polyglot-sql>=0.9.2

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/crates/sqlbuild-kata-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-kata-native"
-version = "0.67.2"
+version = "0.68.0"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.67.2"
+version = "0.68.0"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/src/sqlbuild/adapter/contract/classes/base_adapter.py

@@ -9,6 +9,7 @@ from decimal import Decimal
 from pathlib import Path
 from typing import Any, ClassVar, cast
 
+from sqlbuild.adapter.contract.classes.retention_adapter import RetentionAdapterMixin
 from sqlbuild.adapter.contract.classes.statement_recorder import StatementRecorder
 from sqlbuild.adapter.contract.classes.strict_adapter import StrictAdapter
 from sqlbuild.adapter.contract.constants import (
@@ -73,7 +74,7 @@ _COLLECTION_SQL_VALUE_KINDS: frozenset[SqlValueKind] = frozenset(
 )
 
 
-class BaseAdapter(StrictAdapter):
+class BaseAdapter(RetentionAdapterMixin, StrictAdapter):
     """Adapter base with ANSI SQL defaults."""
 
     adapter_name: ClassVar[str]

sqlbuild-0.68.0/src/sqlbuild/adapter/contract/classes/retention_adapter.py

@@ -0,0 +1,45 @@
+"""Optional adapter retention capability."""
+
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+from sqlbuild.adapter.contract.exceptions import AdapterUserError
+from sqlbuild.adapter.contract.models import (
+    RenderedRetentionChange,
+    RetentionRequest,
+    RetentionState,
+)
+
+
+class RetentionAdapterMixin:
+    """Provide explicit unsupported defaults for warehouse retention operations."""
+
+    adapter_name: ClassVar[str]
+
+    def inspect_retention(self, *, connection: Any, request: RetentionRequest) -> RetentionState:
+        del connection, request
+        raise AdapterUserError(
+            message=f"adapter '{self.adapter_name}' does not support retention inspection"
+        )
+
+    def render_retention_changes(
+        self, *, request: RetentionRequest, state: RetentionState | None = None
+    ) -> tuple[RenderedRetentionChange, ...]:
+        del request, state
+        raise AdapterUserError(
+            message=f"adapter '{self.adapter_name}' does not support retention changes"
+        )
+
+    def render_create_permanent_table_from_relation(
+        self, *, destination: str, origin: str
+    ) -> tuple[str, ...]:
+        return self.render_create_permanent_table_as(
+            destination=destination, sql=f"SELECT * FROM {origin}"
+        )
+
+    def render_create_permanent_table_as(self, *, destination: str, sql: str) -> tuple[str, ...]:
+        del destination, sql
+        raise AdapterUserError(
+            message=f"adapter '{self.adapter_name}' does not support permanent-table migration"
+        )

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/src/sqlbuild/adapter/contract/models.py

@@ -13,6 +13,8 @@ from sqlbuild.adapter.contract.types import (
     CursorKind,
     FunctionNullabilityRule,
     LifeCycleEventKind,
+    RetentionChangePhase,
+    RetentionScope,
     TypeFamily,
 )
 from sqlbuild.compiler.compile.types import FunctionLanguage
@@ -141,6 +143,42 @@ class TableFreshnessRequest:
     name: str
 
 
+@dataclass(frozen=True)
+class RetentionRequest:
+    """One identified desired retention setting for a warehouse object."""
+
+    request_id: str
+    scope: RetentionScope
+    database: str | None
+    schema: str
+    desired_days: int
+    name: str | None = None
+
+
+@dataclass(frozen=True)
+class RetentionState:
+    """Typed warehouse retention values observed for one request."""
+
+    request_id: str
+    scope: RetentionScope
+    configured_days: int | None
+    effective_days: int
+    exists: bool = True
+    relation_kind: str | None = None
+    is_transient: bool | None = None
+    delta_log_retention_days: int | None = None
+    delta_deleted_file_retention_days: int | None = None
+    max_time_travel_hours: int | None = None
+
+
+@dataclass(frozen=True)
+class RenderedRetentionChange:
+    """One ordered phase of SQL statements for a retention change."""
+
+    phase: RetentionChangePhase
+    statements: tuple[str, ...]
+
+
 @dataclass(frozen=True)
 class FunctionInfo:
     """Metadata for one discovered warehouse function or routine."""

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/src/sqlbuild/adapter/contract/types.py

@@ -41,6 +41,17 @@ class TablePromotionMode(StrEnum):
     STAGED = "staged"
 
 
+class RetentionScope(StrEnum):
+    RELATION = "relation"
+    NAMESPACE = "namespace"
+
+
+class RetentionChangePhase(StrEnum):
+    PREPARE = "prepare"
+    ALTER = "alter"
+    FINALIZE = "finalize"
+
+
 class RelationType(StrEnum):
     TABLE = "table"
     VIEW = "view"

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/src/sqlbuild/adapters/bigquery/classes/bigquery_adapter.py

@@ -33,6 +33,9 @@ from sqlbuild.adapter.contract.models import (
     FunctionInfo,
     QueryResult,
     RelationInfo,
+    RenderedRetentionChange,
+    RetentionRequest,
+    RetentionState,
     RowDiffColumnResult,
     RowDiffResult,
     RowDiffSampleCell,
@@ -50,6 +53,8 @@ from sqlbuild.adapter.contract.types import (
     FrameworkType,
     LoaderLogicalType,
     PromotionStrategy,
+    RetentionChangePhase,
+    RetentionScope,
     TablePromotionMode,
 )
 from sqlbuild.adapter.relations.main.get_columns_for_relations import (
@@ -109,6 +114,60 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
     sql_analysis_dialect_name: ClassVar[str | None] = "bigquery"
     max_identifier_length: ClassVar[int] = 1024
 
+    def inspect_retention(
+        self, *, connection: _BigQueryConnection, request: RetentionRequest
+    ) -> RetentionState:
+        dataset_id: str = self._retention_dataset_id(request=request)
+        try:
+            dataset: Any = connection.client.get_dataset(dataset_id)
+        except Exception as error:
+            if not self._is_google_not_found(error):
+                raise
+            return RetentionState(
+                request_id=request.request_id,
+                scope=request.scope,
+                configured_days=None,
+                effective_days=7,
+                exists=False,
+                max_time_travel_hours=168,
+            )
+        hours: object | None = getattr(dataset, "max_time_travel_hours", None)
+        if not isinstance(hours, int):
+            raise AdapterUserError(
+                message=f"BigQuery dataset {dataset_id} has no max_time_travel_hours metadata"
+            )
+        return RetentionState(
+            request_id=request.request_id,
+            scope=request.scope,
+            configured_days=hours // 24,
+            effective_days=hours // 24,
+            max_time_travel_hours=hours,
+        )
+
+    def render_retention_changes(
+        self, *, request: RetentionRequest, state: RetentionState | None = None
+    ) -> tuple[RenderedRetentionChange, ...]:
+        del state
+        dataset_id: str = self._retention_dataset_id(request=request)
+        return (
+            RenderedRetentionChange(
+                phase=RetentionChangePhase.ALTER,
+                statements=(
+                    f"ALTER SCHEMA {self._quote_identifier_path(dataset_id)} SET OPTIONS "
+                    f"(max_time_travel_hours = {request.desired_days * 24})",
+                ),
+            ),
+        )
+
+    def _retention_dataset_id(self, *, request: RetentionRequest) -> str:
+        if request.scope != RetentionScope.NAMESPACE or request.name is not None:
+            raise AdapterUserError(message="BigQuery retention requires namespace scope")
+        minimum_days: int = 2
+        maximum_days: int = 7
+        if not minimum_days <= request.desired_days <= maximum_days:
+            raise AdapterUserError(message="BigQuery retention days must be between 2 and 7")
+        return self._build_dataset_id(database=request.database, schema=request.schema)
+
     def render_read_latest_fingerprints_sql(
         self,
         *,

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/src/sqlbuild/adapters/databricks/classes/databricks_adapter.py

@@ -6,6 +6,7 @@ import ast
 import csv
 import json
 import logging
+import re
 from datetime import date, datetime
 from decimal import Decimal
 from pathlib import Path
@@ -30,6 +31,9 @@ from sqlbuild.adapter.contract.models import (
     FunctionInfo,
     QueryResult,
     RelationInfo,
+    RenderedRetentionChange,
+    RetentionRequest,
+    RetentionState,
     RowDiffColumnResult,
     RowDiffResult,
     RowDiffSampleCell,
@@ -48,6 +52,8 @@ from sqlbuild.adapter.contract.types import (
     LoaderLogicalType,
     PromotionStrategy,
     RelationType,
+    RetentionChangePhase,
+    RetentionScope,
     TablePromotionMode,
 )
 from sqlbuild.adapter.relations.main.get_columns_for_relations import (
@@ -64,6 +70,9 @@ from sqlbuild.adapter.type_system.main.normalize_numeric_family import normalize
 from sqlbuild.adapter.type_system.main.types_equal import types_equal
 from sqlbuild.adapters.databricks.classes.databricks_connection import _DatabricksConnection
 from sqlbuild.adapters.databricks.constants import (
+    DELTA_DEFAULT_DELETED_FILE_RETENTION_DAYS,
+    DELTA_DEFAULT_LOG_RETENTION_DAYS,
+    DELTA_RELATION_FORMAT,
     NON_ROW_RESULT_COLUMN_NAMES,
     TABLE_RELATION_METADATA_TYPES,
 )
@@ -93,6 +102,168 @@ class DatabricksAdapter(MicrobatchMixin, BaseAdapter):
     sql_analysis_dialect_name: ClassVar[str | None] = "databricks"
     max_identifier_length: ClassVar[int] = 255
 
+    def inspect_retention(self, *, connection: Any, request: RetentionRequest) -> RetentionState:
+        target: str = self._retention_relation_target(request=request)
+        cursor: Any = connection.cursor()
+        try:
+            cursor.execute(f"DESCRIBE DETAIL {target}")
+            row: tuple[Any, ...] | None = cursor.fetchone()
+            description: tuple[Any, ...] | None = cursor.description
+        finally:
+            cursor.close()
+        if row is None or description is None:
+            raise AdapterUserError(message="Databricks retention metadata is missing")
+        detail: dict[str, object] = {
+            str(column[0]).lower(): value for column, value in zip(description, row, strict=True)
+        }
+        relation_format: str = str(detail.get("format", "missing"))
+        if relation_format.lower() != DELTA_RELATION_FORMAT:
+            raise AdapterUserError(
+                message=f"Databricks retention requires a Delta relation; found {relation_format}"
+            )
+        properties: dict[str, object] = self._delta_properties(detail.get("properties"))
+        log_days: int = self._parse_delta_retention_days(
+            value=properties.get(
+                "delta.logRetentionDuration",
+                f"interval {DELTA_DEFAULT_LOG_RETENTION_DAYS} days",
+            ),
+            property_name="log",
+        )
+        deleted_days: int = self._parse_delta_retention_days(
+            value=properties.get(
+                "delta.deletedFileRetentionDuration",
+                f"interval {DELTA_DEFAULT_DELETED_FILE_RETENTION_DAYS} days",
+            ),
+            property_name="deleted file",
+        )
+        return RetentionState(
+            request_id=request.request_id,
+            scope=request.scope,
+            configured_days=None,
+            effective_days=min(log_days, deleted_days),
+            relation_kind="DELTA",
+            delta_log_retention_days=log_days,
+            delta_deleted_file_retention_days=deleted_days,
+        )
+
+    def render_retention_changes(
+        self, *, request: RetentionRequest, state: RetentionState | None = None
+    ) -> tuple[RenderedRetentionChange, ...]:
+        target: str = self._retention_relation_target(request=request)
+        days: int = request.desired_days
+        if state is not None:
+            log_days: int = state.delta_log_retention_days or state.effective_days
+            deleted_days: int = state.delta_deleted_file_retention_days or state.effective_days
+            changes: list[RenderedRetentionChange] = []
+            required_log_days: int = max(days, deleted_days)
+            if log_days < required_log_days:
+                changes.append(
+                    self._render_delta_retention_property(
+                        target=target,
+                        property_name="log",
+                        days=required_log_days,
+                        increase=True,
+                    )
+                )
+                log_days = required_log_days
+            if deleted_days < days:
+                changes.append(
+                    self._render_delta_retention_property(
+                        target=target, property_name="deletedFile", days=days, increase=True
+                    )
+                )
+                deleted_days = days
+            if deleted_days > days:
+                changes.append(
+                    self._render_delta_retention_property(
+                        target=target, property_name="deletedFile", days=days, increase=False
+                    )
+                )
+            if log_days > days:
+                changes.append(
+                    self._render_delta_retention_property(
+                        target=target, property_name="log", days=days, increase=False
+                    )
+                )
+            return tuple(changes)
+        return (
+            RenderedRetentionChange(
+                phase=RetentionChangePhase.ALTER,
+                statements=(
+                    f"ALTER TABLE {target} SET TBLPROPERTIES "
+                    f"('delta.logRetentionDuration' = 'interval {days} days', "
+                    f"'delta.deletedFileRetentionDuration' = 'interval {days} days')",
+                ),
+            ),
+        )
+
+    @staticmethod
+    def _render_delta_retention_property(
+        *, target: str, property_name: str, days: int, increase: bool
+    ) -> RenderedRetentionChange:
+        return RenderedRetentionChange(
+            phase=(RetentionChangePhase.PREPARE if increase else RetentionChangePhase.FINALIZE),
+            statements=(
+                f"ALTER TABLE {target} SET TBLPROPERTIES "
+                f"('delta.{property_name}RetentionDuration' = 'interval {days} days')",
+            ),
+        )
+
+    def _retention_relation_target(self, *, request: RetentionRequest) -> str:
+        if request.scope != RetentionScope.RELATION or request.name is None:
+            raise AdapterUserError(message="Databricks retention requires relation scope")
+        if request.desired_days < 0:
+            raise AdapterUserError(message="Databricks retention days must be non-negative")
+        target: str | None = self.render_qualified_name(
+            database=request.database,
+            schema=request.schema,
+            name=request.name,
+        )
+        if target is None:
+            raise AdapterUserError(
+                message="Databricks retention requires catalog, schema, and relation"
+            )
+        return target
+
+    @staticmethod
+    def _parse_delta_retention_days(*, value: object, property_name: str) -> int:
+        match: re.Match[str] | None = re.fullmatch(
+            r"\s*interval\s+(\d+)\s+(hours?|days?|weeks?)\s*",
+            str(value),
+            flags=re.IGNORECASE,
+        )
+        if match is None:
+            raise AdapterUserError(
+                message=f"Databricks Delta {property_name} retention is missing or unparseable"
+            )
+        amount: int = int(match.group(1))
+        unit: str = match.group(2).lower()
+        if unit.startswith("week"):
+            return amount * 7
+        if unit.startswith("hour"):
+            if amount % 24 != 0:
+                raise AdapterUserError(
+                    message=(
+                        f"Databricks Delta {property_name} retention is not a whole-day interval: "
+                        f"{value!r}"
+                    )
+                )
+            return amount // 24
+        return amount
+
+    @staticmethod
+    def _delta_properties(value: object) -> dict[str, object]:
+        if isinstance(value, dict):
+            return {str(key): item for key, item in value.items()}
+        if isinstance(value, str):
+            try:
+                parsed: object = json.loads(value)
+            except json.JSONDecodeError:
+                parsed = ast.literal_eval(value)
+            if isinstance(parsed, dict):
+                return {str(key): item for key, item in parsed.items()}
+        raise AdapterUserError(message="Databricks Delta retention properties are missing")
+
     def render_read_latest_fingerprints_sql(
         self,
         *,

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/src/sqlbuild/adapters/databricks/constants.py

@@ -2,3 +2,6 @@
 
 NON_ROW_RESULT_COLUMN_NAMES: frozenset[str] = frozenset({"status", "result"})
 TABLE_RELATION_METADATA_TYPES: frozenset[str] = frozenset({"managed", "external", "base table"})
+DELTA_RELATION_FORMAT: str = "delta"
+DELTA_DEFAULT_LOG_RETENTION_DAYS: int = 30
+DELTA_DEFAULT_DELETED_FILE_RETENTION_DAYS: int = 7

{sqlbuild-0.67.2 → sqlbuild-0.68.0}/src/sqlbuild/adapters/snowflake/classes/snowflake_adapter.py

@@ -29,6 +29,9 @@ from sqlbuild.adapter.contract.models import (
     FunctionInfo,
     QueryResult,
     RelationInfo,
+    RenderedRetentionChange,
+    RetentionRequest,
+    RetentionState,
     RowDiffColumnResult,
     RowDiffResult,
     RowDiffSampleCell,
@@ -46,6 +49,8 @@ from sqlbuild.adapter.contract.types import (
     FrameworkType,
     LoaderLogicalType,
     PromotionStrategy,
+    RetentionChangePhase,
+    RetentionScope,
     TablePromotionMode,
 )
 from sqlbuild.adapter.state_sql.main.render_insert_source_freshness_records_sql import (
@@ -98,6 +103,82 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
         {"source", "profile", "target", "project_dir", "profiles_dir"}
     )
 
+    def inspect_retention(self, *, connection: Any, request: RetentionRequest) -> RetentionState:
+        self._validate_relation_retention_request(request=request)
+        clauses: list[str] = ["table_name = %s", "table_schema = %s"]
+        params: list[str] = [
+            self._information_schema_identifier(str(request.name)),
+            self._information_schema_identifier(request.schema),
+        ]
+        if request.database is not None:
+            clauses.append("table_catalog = %s")
+            params.append(self._information_schema_identifier(request.database))
+        cursor: Any = connection.cursor()
+        try:
+            cursor.execute(
+                "SELECT retention_time, is_transient FROM "
+                + self._information_schema_relation(database=request.database, name="tables")
+                + " WHERE "
+                + " AND ".join(clauses),
+                tuple(params),
+            )
+            row: tuple[Any, ...] | None = cursor.fetchone()
+        finally:
+            cursor.close()
+        if row is None:
+            raise AdapterUserError(
+                message=f"Snowflake retention metadata not found for {request.name}"
+            )
+        effective_days: int = int(row[0])
+        is_transient: bool = str(row[1]).upper() == TRUE_METADATA_VALUE
+        return RetentionState(
+            request_id=request.request_id,
+            scope=request.scope,
+            configured_days=None,
+            effective_days=effective_days,
+            relation_kind="TRANSIENT" if is_transient else "PERMANENT",
+            is_transient=is_transient,
+        )
+
+    def render_retention_changes(
+        self, *, request: RetentionRequest, state: RetentionState | None = None
+    ) -> tuple[RenderedRetentionChange, ...]:
+        del state
+        self._validate_relation_retention_request(request=request)
+        target: str | None = self.render_qualified_name(
+            database=request.database,
+            schema=request.schema,
+            name=str(request.name),
+        )
+        if target is None:
+            raise AdapterUserError(message="Snowflake retention requires a schema and relation")
+        return (
+            RenderedRetentionChange(
+                phase=RetentionChangePhase.ALTER,
+                statements=(
+                    f"ALTER TABLE {target} SET DATA_RETENTION_TIME_IN_DAYS = "
+                    f"{request.desired_days}",
+                ),
+            ),
+        )
+
+    def render_create_permanent_table_from_relation(
+        self, *, destination: str, origin: str
+    ) -> tuple[str, ...]:
+        return self.render_create_permanent_table_as(
+            destination=destination, sql=f"SELECT * FROM {origin}"
+        )
+
+    def render_create_permanent_table_as(self, *, destination: str, sql: str) -> tuple[str, ...]:
+        return (f"CREATE TABLE {destination} AS {sql}",)
+
+    @staticmethod
+    def _validate_relation_retention_request(*, request: RetentionRequest) -> None:
+        if request.scope != RetentionScope.RELATION or request.name is None:
+            raise AdapterUserError(message="Snowflake retention requires relation scope")
+        if request.desired_days < 0:
+            raise AdapterUserError(message="Snowflake retention days must be non-negative")
+
     def cost_capability(self) -> CostCapability:
         return CostCapability.SNOWFLAKE_QUERY_HISTORY
 
@@ -790,10 +871,9 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
     ) -> None:
         statements: tuple[str, ...] = self.render_swap(left=left, right=right)
         statement_recorder.record_many(statements)
-        with self.transaction(connection):
-            stmt: str
-            for stmt in statements:
-                self.execute(connection=connection, sql=stmt)
+        stmt: str
+        for stmt in statements:
+            self.execute(connection=connection, sql=stmt)
 
     def clone(
         self,
@@ -1582,7 +1662,7 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
         names: tuple[str, ...] | None = None,
     ) -> tuple[Any, ...]:
         query: str = (
-            "SELECT table_name, table_schema, table_type, is_transient "
+            "SELECT table_name, table_schema, table_type, is_transient, created, last_altered "
             f"FROM {self._information_schema_relation(database=database, name='tables')} WHERE 1=1"
         )
         params: list[str] = []
@@ -1614,6 +1694,8 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
                 is_transient=(
                     None if row[3] is None else str(row[3]).upper() == TRUE_METADATA_VALUE
                 ),
+                created_at=None if row[4] is None else row[4],
+                last_altered_at=None if row[5] is None else row[5],
             )
             for row in rows
         )

sqlbuild-0.68.0/src/sqlbuild/archives/__init__.py

@@ -0,0 +1 @@
+"""Append-only safety archive state and naming."""

sqlbuild-0.68.0/src/sqlbuild/archives/_helpers/__init__.py

@@ -0,0 +1 @@
+"""Internal archive helpers."""

sqlbuild-0.68.0/src/sqlbuild/archives/_helpers/identity.py

@@ -0,0 +1,42 @@
+"""Deterministic archive requirement and event identities."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+
+from sqlbuild.archives.types import ArchiveRecordType
+
+
+def archive_requirement_id(
+    *,
+    operation_kind: str,
+    target_database: str | None,
+    target_schema: str,
+    target_name: str,
+    source_physical_generation: str | None,
+    archive_name: str,
+) -> str:
+    """Return a stable requirement ID for one source incarnation and archive name."""
+
+    return _digest(
+        (
+            operation_kind,
+            target_database,
+            target_schema,
+            target_name,
+            source_physical_generation,
+            archive_name,
+        )
+    )
+
+
+def archive_event_id(*, requirement_id: str, record_type: ArchiveRecordType) -> str:
+    """Return a stable ID for one immutable lifecycle fact."""
+
+    return _digest((requirement_id, record_type.value))
+
+
+def _digest(values: tuple[object, ...]) -> str:
+    encoded: str = json.dumps(values, separators=(",", ":"), ensure_ascii=True)
+    return hashlib.sha256(encoded.encode()).hexdigest()