onec-interactive-runtime-core 0.1.19__py3-none-any.whl

onec_runtime/bsl/notebook_cells.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+from bisect import bisect_left
+from dataclasses import dataclass, field
+from typing import Any
+
+from onec_runtime.bsl.lexer import tokenize
+from onec_runtime.bsl.parser_target import PythonParserTarget
+from onec_runtime.bsl.semantic_lowering import WorkerExport
+from onec_runtime.bsl.source_maps import (
+    MappedSource,
+    SourceArtifactKind,
+    SourceSpan,
+    SourceTransformBuilder,
+    SourceUnitKind,
+    SourceUnitRef,
+    mapped_visible_source,
+    source_sha256,
+)
+from onec_runtime.errors import ProtocolError
+
+
+@dataclass(frozen=True, slots=True)
+class NotebookMethodProjection:
+    """One complete AST method, including decorations and generated export."""
+
+    export: WorkerExport
+    mapped_source: MappedSource = field(repr=False)
+
+
+@dataclass(frozen=True, slots=True)
+class NotebookCellProjection:
+    """Generated-AST projections of one immutable visible notebook cell."""
+
+    visible: MappedSource = field(repr=False)
+    worker: MappedSource | None = field(repr=False)
+    statements: MappedSource | None = field(repr=False)
+    exports: tuple[WorkerExport, ...]
+    methods: tuple[NotebookMethodProjection, ...] = field(default=(), repr=False)
+
+    @property
+    def worker_source(self) -> str:
+        return "" if self.worker is None else self.worker.text
+
+    @property
+    def statement_source(self) -> str:
+        return "" if self.statements is None else self.statements.text
+
+    @property
+    def has_methods(self) -> bool:
+        return self.worker is not None
+
+    @property
+    def has_statements(self) -> bool:
+        return self.statements is not None
+
+
+# Preserve imports of the former plain-string result type while making mapped
+# projections authoritative.
+NotebookCell = NotebookCellProjection
+
+
+@dataclass(frozen=True, slots=True)
+class _ProjectionItem:
+    ordinal: int
+    node: Any
+    end: int
+
+
+def split_notebook_cell(
+    parser_target: PythonParserTarget,
+    source: str,
+    *,
+    source_unit: SourceUnitRef | None = None,
+) -> NotebookCellProjection:
+    """Split a generated cell AST into independent mapped execution branches."""
+    unit = source_unit or SourceUnitRef(
+        SourceUnitKind.NOTEBOOK_CELL,
+        "anonymous-notebook-cell",
+        0,
+        source_sha256(source),
+    )
+    visible = mapped_visible_source(source, unit)
+    root = parser_target.parse_ast(source, "ЯчейкаНоутбука")
+    tokens = tokenize(source)
+    token_starts = tuple(token.start for token in tokens)
+    elements = root.Elements
+    ordered: list[Any] = []
+    while elements is not None and elements.Item is not None:
+        ordered.append(elements.Item)
+        elements = elements.Rest
+
+    method_items: list[_ProjectionItem] = []
+    statement_items: list[_ProjectionItem] = []
+    exports: dict[str, WorkerExport] = {}
+    for ordinal, item in enumerate(ordered):
+        following_start = (
+            ordered[ordinal + 1].span.start
+            if ordinal + 1 < len(ordered)
+            else len(source)
+        )
+        projected = _ProjectionItem(
+            ordinal,
+            item,
+            _projection_end(item.span.end, following_start, tokens, token_starts),
+        )
+        if type(item).__name__ == "Method":
+            declaration = item.Declaration
+            export = WorkerExport(declaration.Name, declaration.Name)
+            key = export.public_path.casefold()
+            if key in exports:
+                raise ProtocolError(
+                    f"Notebook cell declares duplicate method {declaration.Name!r}"
+                )
+            exports[key] = export
+            method_items.append(projected)
+        else:
+            statement_items.append(projected)
+
+    return NotebookCellProjection(
+        visible,
+        _build_projection(
+            visible,
+            method_items,
+            tokens,
+            SourceArtifactKind.WORKER_PROJECTION,
+        ),
+        _build_projection(
+            visible,
+            statement_items,
+            tokens,
+            SourceArtifactKind.STATEMENT_PROJECTION,
+        ),
+        tuple(exports.values()),
+        tuple(
+            NotebookMethodProjection(
+                export,
+                _build_method_projection(visible, item, tokens),
+            )
+            for export, item in zip(exports.values(), method_items, strict=True)
+        ),
+    )
+
+
+def _build_method_projection(
+    visible: MappedSource,
+    item: _ProjectionItem,
+    tokens: tuple[Any, ...],
+) -> MappedSource:
+    builder = SourceTransformBuilder(visible)
+    # The optional semicolon belongs to the notebook element separator, not
+    # the method AST. In a composed Worker it starts the module body and makes
+    # every subsequently appended declaration illegal on the platform.
+    method = _ProjectionItem(item.ordinal, item.node, item.node.span.end)
+    _copy_method(builder, method, tokens)
+    return builder.build(SourceArtifactKind.WORKER_PROJECTION)
+
+
+def _projection_end(
+    item_end: int,
+    following_start: int,
+    tokens: tuple[Any, ...],
+    token_starts: tuple[int, ...],
+) -> int:
+    """Include one grammar separator using its generated token span."""
+    token_index = bisect_left(token_starts, item_end)
+    following = (
+        tokens[token_index]
+        if token_index < len(tokens) and tokens[token_index].start < following_start
+        else None
+    )
+    return following.end if following is not None and following.type == ";" else item_end
+
+
+def _build_projection(
+    visible: MappedSource,
+    items: list[_ProjectionItem],
+    tokens: tuple[Any, ...],
+    kind: SourceArtifactKind,
+) -> MappedSource | None:
+    if not items:
+        return None
+    builder = SourceTransformBuilder(visible)
+    previous: _ProjectionItem | None = None
+    for item in items:
+        if previous is not None:
+            if item.ordinal == previous.ordinal + 1:
+                separator = SourceSpan(previous.end, item.node.span.start)
+                if separator.start < separator.end:
+                    builder.copy(separator)
+            else:
+                builder.synthetic(
+                    "\n",
+                    SourceSpan(item.node.span.start, item.node.span.start),
+                    "notebook_projection_join",
+                )
+        if kind is SourceArtifactKind.WORKER_PROJECTION:
+            _copy_method(builder, item, tokens)
+        else:
+            builder.copy(SourceSpan(item.node.span.start, item.end))
+        previous = item
+    return builder.build(kind)
+
+
+def _copy_method(
+    builder: SourceTransformBuilder,
+    item: _ProjectionItem,
+    tokens: tuple[Any, ...],
+) -> None:
+    method = item.node
+    declaration = method.Declaration
+    if declaration.Export is not None:
+        builder.copy(SourceSpan(method.span.start, item.end))
+        return
+    body_start = declaration.Body.span.start
+    closing = next(
+        (
+            token
+            for token in reversed(tokens)
+            if method.span.start <= token.start < body_start and token.type == ")"
+        ),
+        None,
+    )
+    if closing is None:
+        raise ProtocolError("Notebook method declaration has no parameter-list terminator")
+    builder.copy(SourceSpan(method.span.start, closing.end))
+    builder.synthetic(
+        " Экспорт",
+        SourceSpan(method.span.start, closing.end),
+        "notebook_method_export",
+    )
+    builder.copy(SourceSpan(closing.end, item.end))

onec_runtime/bsl/notebook_method_globals.py

@@ -0,0 +1,74 @@
+"""Bind free notebook-method reads to the live request-scoped BSL context."""
+
+from __future__ import annotations
+
+from onec_runtime.bsl.lexer import tokenize
+from onec_runtime.bsl.parser_target import PythonParserTarget
+from onec_runtime.bsl.semantic_lowering import SemanticNotebookLowerer, WorkerExport
+from onec_runtime.bsl.source_maps import (
+    MappedSource,
+    SourceArtifactKind,
+    SourceSpan,
+    SourceTransformBuilder,
+)
+from onec_runtime.errors import ProtocolError
+
+
+WORKER_GLOBALS = "__OnecNotebookGlobals"
+_CONTEXT_PREFIX = f"{WORKER_GLOBALS}."
+
+
+def bind_notebook_method_globals(
+    source: MappedSource,
+    *,
+    context_names: tuple[str, ...],
+    exports: tuple[WorkerExport, ...],
+) -> tuple[MappedSource, tuple[str, ...]]:
+    """Qualify persistent roots without changing method-local BSL semantics."""
+    if not context_names:
+        return source, ()
+    if any(
+        token.type == "ID" and token.text.casefold() == WORKER_GLOBALS.casefold()
+        for token in tokenize(source.text)
+    ):
+        raise ProtocolError("Notebook method uses a reserved Worker globals name")
+    binding = SemanticNotebookLowerer(
+        PythonParserTarget.from_generated(),
+        context_names=context_names,
+        worker_exports=exports,
+        platform_globals=("RuntimeContextStoreServer",),
+    ).bind_module(source.text)
+    references = sorted(
+        (
+            reference
+            for method in binding.method_scopes
+            for reference in method.references
+            if reference.kind == "persistent"
+        ),
+        key=lambda reference: reference.span.start,
+    )
+    if not references:
+        return source, ()
+
+    builder = SourceTransformBuilder(source)
+    builder.synthetic(
+        f"Перем {WORKER_GLOBALS} Экспорт;\n",
+        SourceSpan(0, 0),
+        "notebook_method_globals_declaration",
+    )
+    cursor = 0
+    names: dict[str, str] = {}
+    for reference in references:
+        root = reference.span
+        names.setdefault(reference.name.casefold(), reference.name)
+        if root.start < cursor:
+            raise ValueError("overlapping notebook method bindings")
+        builder.copy(SourceSpan(cursor, root.start))
+        builder.synthetic(
+            _CONTEXT_PREFIX,
+            SourceSpan(root.start, root.start),
+            "notebook_method_persistent_read",
+        )
+        cursor = root.start
+    builder.copy(SourceSpan(cursor, len(source.text)))
+    return builder.build(SourceArtifactKind.WORKER_PROJECTION), tuple(names.values())

onec_runtime/bsl/notebook_methods.py

@@ -0,0 +1,175 @@
+"""Immutable notebook method upserts with original visible source ownership."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from onec_runtime.bsl.diagnostics import VisibleSourceContext
+from onec_runtime.bsl.lexer import Token, tokenize
+from onec_runtime.bsl.notebook_cells import NotebookCellProjection, NotebookMethodProjection
+from onec_runtime.bsl.semantic_lowering import WorkerExport
+from onec_runtime.bsl.source_maps import (
+    MappedSource,
+    SourceArtifactKind,
+    SourceSpan,
+    SourceTransformBuilder,
+    SourceUnitRef,
+    compose_mapped_sources,
+)
+from onec_runtime.errors import ProtocolError
+
+
+@dataclass(frozen=True, slots=True)
+class _RetainedMethod:
+    projection: NotebookMethodProjection = field(repr=False)
+    visible: MappedSource = field(repr=False)
+
+
+@dataclass(frozen=True, slots=True)
+class NotebookMethodSet:
+    """A candidate value; publication and commitment belong to the runtime."""
+
+    mapped_source: MappedSource = field(repr=False)
+    exports: tuple[WorkerExport, ...]
+    intercepts_messages: bool
+    _methods: tuple[_RetainedMethod, ...] = field(repr=False)
+    _visible_sources: tuple[MappedSource, ...] = field(repr=False)
+    bound_globals: tuple[str, ...] = ()
+
+    @property
+    def visible_source_context(self) -> VisibleSourceContext:
+        # VisibleSourceContext is mutable. Hand out a detached index rather than
+        # allowing consumers to alter the retained candidate's diagnostic state.
+        return VisibleSourceContext(
+            {_visible_unit(source): source.text for source in self._visible_sources}
+        )
+
+
+def _visible_unit(source: MappedSource) -> SourceUnitRef:
+    unit = source.source_map.map_offset(0).unit
+    if source.artifact.kind is not SourceArtifactKind.VISIBLE or unit is None:
+        raise ProtocolError("Notebook method origin must be a visible source unit")
+    return unit
+
+
+def _unique_visible_sources(sources: tuple[MappedSource, ...]) -> tuple[MappedSource, ...]:
+    retained: dict[tuple[object, str, int], MappedSource] = {}
+    for source in sources:
+        unit = _visible_unit(source)
+        key = (unit.kind, unit.unit_id, unit.revision)
+        existing = retained.get(key)
+        if existing is not None and _visible_unit(existing).source_sha256 != unit.source_sha256:
+            raise ProtocolError("Notebook methods have conflicting source identities")
+        retained[key] = source
+    return tuple(retained.values())
+
+
+_MESSAGE_SINK = "__OnecWorkerMessageSink"
+_MESSAGE_HELPER = "__OnecWorkerMessage"
+
+
+def _message_call_tokens(source: str) -> tuple[Token, ...]:
+    tokens = tokenize(source)
+    return tuple(
+        token
+        for index, token in enumerate(tokens)
+        if token.type == "ID"
+        and token.text.casefold() in {"сообщить", "message"}
+        and index + 1 < len(tokens)
+        and tokens[index + 1].type == "("
+        and (
+            index == 0
+            or tokens[index - 1].type not in {".", "ПРОЦЕДУРА", "ФУНКЦИЯ"}
+        )
+    )
+
+
+def instrument_notebook_worker_messages(source: MappedSource) -> MappedSource:
+    """Route notebook method messages to the active cell without losing origins."""
+    calls = _message_call_tokens(source.text)
+    if not calls:
+        return source
+    reserved = {_MESSAGE_SINK.casefold(), _MESSAGE_HELPER.casefold()}
+    if any(
+        token.type == "ID" and token.text.casefold() in reserved
+        for token in tokenize(source.text)
+    ):
+        raise ProtocolError("Notebook method uses a reserved Worker message name")
+    builder = SourceTransformBuilder(source)
+    builder.synthetic(
+        f"Перем {_MESSAGE_SINK} Экспорт;\n",
+        SourceSpan(0, 0),
+        "worker_message_sink_declaration",
+    )
+    position = 0
+    for call in calls:
+        builder.copy(SourceSpan(position, call.start))
+        builder.derived(
+            _MESSAGE_HELPER,
+            SourceSpan(call.start, call.end),
+            "worker_message_call",
+        )
+        position = call.end
+    builder.copy(SourceSpan(position, len(source.text)))
+    builder.synthetic(
+        "\n\n"
+        f"Процедура {_MESSAGE_HELPER}(Текст = Неопределено, Статус = Неопределено)\n"
+        f"    Если {_MESSAGE_SINK} = Неопределено Тогда\n"
+        "        Если Статус = Неопределено Тогда\n"
+        "            Сообщить(Текст);\n"
+        "        Иначе\n"
+        "            Сообщить(Текст, Статус);\n"
+        "        КонецЕсли;\n"
+        "    Иначе\n"
+        f"        RuntimeKernelServer.ДобавитьСообщение({_MESSAGE_SINK}, Текст, Статус);\n"
+        "    КонецЕсли;\n"
+        "КонецПроцедуры",
+        SourceSpan(len(source.text), len(source.text)),
+        "worker_message_helper",
+    )
+    return builder.build(SourceArtifactKind.WORKER_PROJECTION)
+
+
+def merge_notebook_methods(
+    previous: NotebookMethodSet | None,
+    cell: NotebookCellProjection,
+) -> NotebookMethodSet:
+    """Replace declared names in place, append new names, retain omitted names."""
+    if previous is not None and not isinstance(previous, NotebookMethodSet):
+        raise ProtocolError("Previous notebook methods must be a NotebookMethodSet")
+    if not isinstance(cell, NotebookCellProjection):
+        raise ProtocolError("Notebook methods require a parsed cell projection")
+    if tuple(method.export for method in cell.methods) != cell.exports:
+        raise ProtocolError("Notebook method projections do not match their exports")
+    # Check before replacement: even replacing the last old method cannot reuse
+    # its explicit identity with a different hash.
+    _unique_visible_sources(
+        (() if previous is None else previous._visible_sources) + (cell.visible,)
+    )
+    methods = {
+        method.projection.export.method.casefold(): method
+        for method in (() if previous is None else previous._methods)
+    }
+    declared: set[str] = set()
+    for projection in cell.methods:
+        key = projection.export.method.casefold()
+        if key in declared:
+            raise ProtocolError("Notebook cell declares duplicate methods")
+        declared.add(key)
+        methods[key] = _RetainedMethod(projection, cell.visible)
+    retained = tuple(methods.values())
+    visible_sources = _unique_visible_sources(
+        tuple(method.visible for method in retained) + (cell.visible,)
+    )
+    mapped = compose_mapped_sources(
+        tuple(method.projection.mapped_source for method in retained),
+        visible_sources=visible_sources,
+        kind=SourceArtifactKind.WORKER_PROJECTION,
+    )
+    return NotebookMethodSet(
+        mapped,
+        tuple(method.projection.export for method in retained),
+        bool(_message_call_tokens(mapped.text)),
+        retained,
+        visible_sources,
+    )

onec_runtime/bsl/parser_artifact_identity.py

@@ -0,0 +1,119 @@
+"""Canonical provenance for consumer-owned generated parser artifacts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from hashlib import sha256
+import json
+from pathlib import Path
+from typing import TypeAlias
+
+
+ManifestOptionValue: TypeAlias = bool | int | str
+ManifestOptions: TypeAlias = tuple[tuple[str, ManifestOptionValue], ...]
+
+
+def parsergen_package_sha256(parsergen_source: Path) -> str:
+    """Hash the normalized Python inputs for one parsergen package checkout."""
+    package = parsergen_source / "parsergen"
+    digest = sha256()
+    for source in sorted(package.rglob("*.py"), key=lambda path: path.as_posix()):
+        relative = source.relative_to(parsergen_source).as_posix().encode("utf-8")
+        digest.update(relative)
+        digest.update(b"\0")
+        normalized = source.read_bytes().replace(b"\r\n", b"\n").replace(b"\r", b"\n")
+        digest.update(normalized)
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def _canonical_json(value: object) -> str:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class ParserArtifactManifest:
+    """Every consumer input that distinguishes one parser artifact from another."""
+
+    schema_version: int
+    backend_id: str
+    artifact_role: str
+    grammar_source_sha256: str
+    parsergen_package_sha256: str | None
+    entrypoints: tuple[tuple[str, str], ...]
+    lookahead: int
+    production_names: tuple[str, ...]
+    optimizer_options: ManifestOptions
+    codegen_options: ManifestOptions
+    identity_sha256: str
+
+    def to_json(self) -> str:
+        return _canonical_json(
+            {
+                "schema_version": self.schema_version,
+                "backend_id": self.backend_id,
+                "artifact_role": self.artifact_role,
+                "grammar_source_sha256": self.grammar_source_sha256,
+                "parsergen_package_sha256": self.parsergen_package_sha256,
+                "entrypoints": self.entrypoints,
+                "lookahead": self.lookahead,
+                "production_names": self.production_names,
+                "optimizer_options": self.optimizer_options,
+                "codegen_options": self.codegen_options,
+                "identity_sha256": self.identity_sha256,
+            }
+        )
+
+
+def build_parser_artifact_manifest(
+    *,
+    backend_id: str,
+    artifact_role: str,
+    grammar_bytes: bytes,
+    parsergen_package_sha256: str | None,
+    entrypoints: tuple[tuple[str, str], ...],
+    lookahead: int,
+    production_names: tuple[str, ...],
+    optimizer_options: ManifestOptions,
+    codegen_options: ManifestOptions,
+) -> ParserArtifactManifest:
+    """Build an identity from raw inputs before any parsing normalization."""
+    payload = {
+        "schema_version": 2,
+        "backend_id": backend_id,
+        "artifact_role": artifact_role,
+        "grammar_source_sha256": sha256(grammar_bytes).hexdigest(),
+        "parsergen_package_sha256": parsergen_package_sha256,
+        "entrypoints": entrypoints,
+        "lookahead": lookahead,
+        "production_names": production_names,
+        "optimizer_options": optimizer_options,
+        "codegen_options": codegen_options,
+    }
+    return ParserArtifactManifest(
+        **payload,
+        identity_sha256=sha256(_canonical_json(payload).encode("utf-8")).hexdigest(),
+    )
+
+
+def verify_parser_artifact_manifest(raw: str) -> ParserArtifactManifest:
+    """Decode a manifest only when its recorded consumer identity is authentic."""
+    decoded = json.loads(raw)
+    if decoded.get("schema_version") != 2:
+        raise ValueError("unsupported parser artifact manifest schema")
+    recorded_identity = decoded.pop("identity_sha256")
+    expected_identity = sha256(_canonical_json(decoded).encode("utf-8")).hexdigest()
+    if recorded_identity != expected_identity:
+        raise ValueError("generated parser artifact identity is invalid")
+    decoded["entrypoints"] = tuple(tuple(item) for item in decoded["entrypoints"])
+    decoded["production_names"] = tuple(decoded["production_names"])
+    decoded["optimizer_options"] = tuple(
+        tuple(item) for item in decoded["optimizer_options"]
+    )
+    decoded["codegen_options"] = tuple(tuple(item) for item in decoded["codegen_options"])
+    return ParserArtifactManifest(**decoded, identity_sha256=recorded_identity)