Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
99 changes: 95 additions & 4 deletions interscript-py/src/interscript/__init__.py
Original file line number Diff line number Diff line change
Expand Up @@ -39,16 +39,32 @@
load_manifest,
verify_artifact,
)
from .reverse import reverse_map, reverse_name

T = TypeVar("T")

DEFAULT_STAGE = "main"


class _ReversedDependencyResolver:
"""Serves reversed dependency documents under their FORWARD names
(run rules reference the forward names) — the runtime-side half of
rs's `reverse_document` dependency recursion."""

def __init__(self, maps: dict[str, object]) -> None:
self._maps = maps

def load(self, system_code: str):
try:
return self._maps[system_code]
except KeyError:
raise MapNotFoundError(system_code) from None


class Runtime:
"""A map runtime bound to a set of artifact load paths.

Mirrors the TS `Intercript` class: default stage "main", dependency
Mirrors the TS `Interscript` class: default stage "main", dependency
maps resolved through the same loader.
"""

Expand All @@ -58,8 +74,13 @@ def __init__(
*,
verify: bool = False,
stage: str = DEFAULT_STAGE,
loader: MapLoader | None = None,
) -> None:
self.loader = MapLoader(load_paths, verify=verify)
# `loader` injects a custom resolver (tests, in-memory corpora);
# default: the artifact loader over `load_paths`.
self.loader: MapLoader = loader if loader is not None else MapLoader(
load_paths, verify=verify
)
self.default_stage = stage

def add_load_path(self, path: Path | str) -> None:
Expand All @@ -72,7 +93,25 @@ def map_exist(self, system_code: str) -> bool:
return self.loader.map_exist(system_code)

def load_map(self, system_code: str):
return self.loader.load(system_code)
"""Parse and cache a compiled map (returns a CompiledMap).

Carries the ruby `Interscript::DSL.parse` reverse-name fallback:
a missing map whose reverse-named sibling exists loads that
sibling and returns its reverse (cached under the requested
name)."""
try:
return self.loader.load(system_code)
except MapNotFoundError as original:
fallback = reverse_name(system_code)
if fallback == system_code:
raise
try:
forward = self.loader.load(fallback)
except MapNotFoundError:
raise original from None
reversed_doc = reverse_map(forward)
self.loader.register(system_code, reversed_doc)
return reversed_doc

def transliterate(
self,
Expand All @@ -90,11 +129,48 @@ def transliterate(
"""
from .executor import execute_stage

map_ = self.loader.load(system_code)
map_ = self.load_map(system_code)
return execute_stage(
map_, stage or self.default_stage, text, self.loader, language
)

def reverse(
self,
system_code: str,
text: str,
stage: str | None = None,
language: str | None = None,
) -> str:
"""Reverse-mode transliteration — the `iscrs reverse` analog:
load the map, reverse it (mirroring rs `reverse_document`, which
recursively reverses embedded dependency documents — here the
whole dependency closure is reversed and served to execution),
then run one stage of the reversed document."""
from .executor import execute_stage

map_ = self.load_map(system_code)

# rs: dependency documents reverse with the parent. Memoized
# closure walk — cycles recurse in rs/ruby too, only repeat
# work is skipped here.
reversed_deps: dict[str, object] = {}

def collect(m) -> None:
for dep in m.dependencies:
if dep in reversed_deps:
continue
dep_map = self.loader.load(dep)
reversed_deps[dep] = reverse_map(dep_map)
collect(dep_map)

collect(map_)

reversed_doc = reverse_map(map_)
loader = _ReversedDependencyResolver(reversed_deps) if reversed_deps else None
return execute_stage(
reversed_doc, stage or self.default_stage, text, loader, language
)


def _default_runtime() -> Runtime:
"""Module-level runtime; resolves paths from `$INTERSCRIPT_MAPS_IR`
Expand Down Expand Up @@ -140,6 +216,18 @@ def transliterate(
return _default_runtime().transliterate(system_code, text, stage, language)


def reverse(
system_code: str,
text: str,
stage: str | None = None,
language: str | None = None,
) -> str:
"""Reverse-mode transliteration (`iscrs reverse` analog): load
`system_code`, reverse the document (dependencies reverse with the
parent), and transliterate `text` through it."""
return _default_runtime().reverse(system_code, text, stage, language)


__all__ = [
"DEFAULT_STAGE",
"ArtifactIntegrityError",
Expand All @@ -160,6 +248,9 @@ def transliterate(
"map_exist",
"map_list",
"parse_isc",
"reverse",
"reverse_map",
"reverse_name",
"transliterate",
"verify_artifact",
]
9 changes: 8 additions & 1 deletion interscript-py/src/interscript/loader.py
Original file line number Diff line number Diff line change
Expand Up @@ -153,7 +153,14 @@ def map_list(self) -> list[str]:
return sorted(self._known)

def map_exist(self, system_code: str) -> bool:
return system_code in self._known
return system_code in self._known or system_code in self._cache

def register(self, system_code: str, map_: CompiledMap) -> None:
"""Register a compiled map directly (bypasses load paths) — the
mirror of interscript-ts's `MapLoader.register`. Used by the
runtime's reverse-name load fallback to cache a reversed
document under the requested name."""
self._cache[system_code] = map_


def _default_cache_dir() -> Path:
Expand Down
Loading
Loading