builtins

Classes:

• AmbientBuiltinBinding –
• BuiltinModuleAsset –

Functions:

• build_cast –
• build_print –
• get_ambient_builtin_imports –
• get_builtin_source –
• is_builtin –
• is_builtin_module_specifier –
• list_builtin_modules –
• load_builtin_module –
• resolve_builtin_resource –

AmbientBuiltinBinding dataclass

AmbientBuiltinBinding(name: str, module: str)

BuiltinModuleAsset dataclass

BuiltinModuleAsset(
    logical_name: str,
    specifier: str,
    origin: str,
    source: str,
    is_package: bool,
)

build_cast

build_cast(value: DataType, target_type: DataType) -> Cast

Source code in packages/arx/src/arx/builtins.py

def build_cast(
    value: astx.DataType, target_type: astx.DataType
) -> irx_astx.Cast:
    """
    title: Build an IRx Cast node.
    parameters:
      value:
        type: astx.DataType
      target_type:
        type: astx.DataType
    returns:
      type: irx_astx.Cast
    """
    return irx_astx.Cast(value=value, target_type=target_type)

build_print

build_print(message: Expr) -> PrintExpr

Source code in packages/arx/src/arx/builtins.py

def build_print(message: astx.Expr) -> irx_astx.PrintExpr:
    """
    title: Build an IRx PrintExpr node.
    parameters:
      message:
        type: astx.Expr
    returns:
      type: irx_astx.PrintExpr
    """
    return irx_astx.PrintExpr(message=message)

get_ambient_builtin_imports

get_ambient_builtin_imports(
    module_key: str,
) -> tuple[ImportFromStmt, ...]

Source code in packages/arx/src/arx/builtins.py

def get_ambient_builtin_imports(
    module_key: str,
) -> tuple[irx_astx.ImportFromStmt, ...]:
    """
    title: Build the implicit builtin imports for one module.
    parameters:
      module_key:
        type: str
    returns:
      type: tuple[irx_astx.ImportFromStmt, Ellipsis]
    """
    grouped_aliases: dict[str, list[irx_astx.AliasExpr]] = {}

    for binding in _AMBIENT_BUILTIN_BINDINGS:
        if module_key == binding.module:
            continue
        aliases = grouped_aliases.setdefault(binding.module, [])
        aliases.append(irx_astx.AliasExpr(binding.name))

    imports: list[irx_astx.ImportFromStmt] = []
    for module_name, aliases in grouped_aliases.items():
        imports.append(irx_astx.ImportFromStmt(aliases, module=module_name))

    return tuple(imports)

get_builtin_source

get_builtin_source(module_name: str) -> str

Source code in packages/arx/src/arx/builtins.py

def get_builtin_source(module_name: str) -> str:
    """
    title: Return the bundled source text for one builtin module.
    parameters:
      module_name:
        type: str
    returns:
      type: str
    """
    return cast(
        str,
        resolve_builtin_resource(module_name).read_text(encoding="utf-8"),
    )

is_builtin

is_builtin(name: str) -> bool

Source code in packages/arx/src/arx/builtins.py

def is_builtin(name: str) -> bool:
    """
    title: Check whether a function name is a parser-level built-in.
    parameters:
      name:
        type: str
    returns:
      type: bool
    """
    return name in {BUILTIN_CAST, BUILTIN_PRINT}

is_builtin_module_specifier

is_builtin_module_specifier(specifier: str) -> bool

Source code in packages/arx/src/arx/builtins.py

def is_builtin_module_specifier(specifier: str) -> bool:
    """
    title: Return whether one specifier targets the bundled builtins.
    parameters:
      specifier:
        type: str
    returns:
      type: bool
    """
    return specifier == BUILTIN_NAMESPACE or specifier.startswith(
        f"{BUILTIN_NAMESPACE}."
    )

list_builtin_modules

list_builtin_modules() -> tuple[str, ...]

Source code in packages/arx/src/arx/builtins.py

def list_builtin_modules() -> tuple[str, ...]:
    """
    title: List bundled builtin module names.
    returns:
      type: tuple[str, Ellipsis]
    """
    module_names: list[str] = []
    seen: set[str] = set()

    for module_name in _iter_builtin_modules(_builtin_root()):
        if module_name in seen:
            raise LookupError(
                f"ambiguous builtin module '{module_name}' in package data"
            )
        seen.add(module_name)
        module_names.append(module_name)

    return tuple(module_names)

load_builtin_module

load_builtin_module(specifier: str) -> BuiltinModuleAsset

Source code in packages/arx/src/arx/builtins.py

def load_builtin_module(specifier: str) -> BuiltinModuleAsset:
    """
    title: Load one builtin module from packaged resources.
    parameters:
      specifier:
        type: str
    returns:
      type: BuiltinModuleAsset
    """
    if specifier == BUILTIN_NAMESPACE:
        resource = _join_resource(_builtin_root(), "__init__.x")
        if not resource.is_file():
            raise LookupError(specifier)
        relative_path = f"{_BUILTIN_RESOURCE_DIR}/__init__.x"
        logical_name = ""
        is_package = True
    else:
        if not is_builtin_module_specifier(specifier):
            raise LookupError(specifier)
        logical_name = specifier.removeprefix(f"{BUILTIN_NAMESPACE}.")
        resource, relative_path, is_package = _resolve_builtin_module_entry(
            logical_name
        )

    return BuiltinModuleAsset(
        logical_name=logical_name,
        specifier=specifier,
        origin=f"{_ARX_RESOURCE_PACKAGE}:{relative_path}",
        source=cast(str, resource.read_text(encoding="utf-8")),
        is_package=is_package,
    )

resolve_builtin_resource

resolve_builtin_resource(module_name: str) -> Traversable

Source code in packages/arx/src/arx/builtins.py

def resolve_builtin_resource(module_name: str) -> Traversable:
    """
    title: Resolve one builtin logical module name to a packaged resource.
    parameters:
      module_name:
        type: str
    returns:
      type: Traversable
    """
    resource, _relative_path, _is_package = _resolve_builtin_module_entry(
        module_name
    )
    return resource