fab-build 0.0.1__py3-none-any.whl

fab/__init__.py

@@ -0,0 +1,4 @@
+# from . import caching
+#
+#
+# __all__ = ["caching"]

fab/__main__.py

@@ -0,0 +1,2 @@
+from . import main
+main.main()

fab/caching/__init__.py

@@ -0,0 +1,5 @@
+from .memory import MemoryCache
+from .nullcache import NullCache
+from .diskcache import DiskCache
+
+__all__ = ["MemoryCache", "NullCache", "DiskCache"]

fab/caching/diskcache.py

@@ -0,0 +1,73 @@
+from typing import override
+from pathlib import Path
+from ..model import Cache
+
+from ..util.string_slices import string_slices
+from ..util.hash_path import hash_path
+
+import blake3
+
+
+class DiskCacheError(RuntimeError):
+    pass
+
+
+class DiskCache(Cache):
+    def __init__(self, root: Path) -> None:
+
+        self.__ops = root / "v1/ops"
+        self.__ops.mkdir(parents=True, exist_ok=True)
+
+        self.__blobs = root / "v1/blobs"
+        self.__blobs.mkdir(parents=True, exist_ok=True)
+
+    def __get_op_path(self, op_key: bytes) -> Path:
+        key_parts = string_slices(op_key.hex(), 2, 2)
+        return self.__ops / key_parts[0] / key_parts[1] / op_key.hex()
+
+    def __get_blob_path(self, blob_key: bytes) -> Path:
+        key_parts = string_slices(blob_key.hex(), 2, 2)
+        return self.__blobs / key_parts[0] / key_parts[1] / blob_key.hex()
+
+    @override
+    def has(self, op_key: bytes) -> bool:
+        op_path = self.__get_op_path(op_key)
+        return op_path.exists()
+
+    @override
+    def get_path(self, op_key: bytes) -> Path:
+        op_path = self.__get_op_path(op_key)
+        if not op_path.is_dir():
+            raise DiskCacheError(f"{op_path} does not exist")
+
+        object_link = op_path / "object"
+        if not object_link.is_symlink():
+            raise DiskCacheError(f"Corrupt cache, {object_link} is not a symlink")
+
+        blob_path = object_link.resolve()
+
+        return blob_path
+
+    @override
+    def store_path(self, op_key: bytes, path: Path) -> Path:
+        if not path.exists():
+            raise DiskCacheError(f"Cannot store non-existent path {path} in cache")
+
+        blob_key = hash_path(blake3.blake3(), path)
+
+        blob_path = self.__get_blob_path(blob_key)
+        blob_path.mkdir(parents=True, exist_ok=True)
+        obj_path = blob_path / path.name
+        if not obj_path.exists():
+            path.rename(obj_path)
+
+        op_path = self.__get_op_path(op_key)
+        if op_path.exists():
+            raise DiskCacheError(
+                f"Operation with key '{op_key.hex()}' already exists in cache"
+            )
+
+        op_path.mkdir(parents=True, exist_ok=True)
+        (op_path / "object").symlink_to(obj_path.relative_to(op_path, walk_up=True))
+
+        return obj_path

fab/caching/memory.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+from typing import override
+
+
+from ..model import Cache
+
+class MemoryCache(Cache):
+    def __init__(self):
+        self.__cached_paths: dict[bytes, Path] = {}
+
+    @override
+    def has(self, op_key: bytes) -> bool:
+        return op_key in self.__cached_paths
+
+    @override
+    def get_path(self, op_key: bytes) -> Path:
+        return self.__cached_paths[op_key]
+
+    @override
+    def store_path(self, op_key: bytes, path: Path) -> Path:
+        self.__cached_paths[op_key] = path
+        return path
+
+    def print_cache(self) -> None:
+        for key, value in self.__cached_paths.items():
+            print(f"{key.hex()}: {value}")

fab/caching/nullcache.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+from typing import override
+from ..model import Cache
+
+class NullCache(Cache):
+    @override
+    def has(self, op_key: bytes) -> bool:
+        return False
+
+    @override
+    def get_path(self, op_key: bytes) -> Path:
+        raise KeyError()
+
+    @override
+    def store_path(self, op_key: bytes, path: Path) -> Path:
+        raise NotImplementedError()

fab/caching/test_diskcache.py

@@ -0,0 +1,52 @@
+import hashlib
+from pathlib import Path
+
+from ..util.hash_path import hash_path
+from ..util.temp_file_structure import TempFileStructure
+from .diskcache import DiskCache
+
+
+def path_key(path: Path) -> str:
+    hashfunc = hashlib.sha256()
+    return hash_path(hashfunc, path).hex()
+
+
+def test_store_has_get_path():
+    with TempFileStructure(
+        [
+            ("objects/file1", "file1"),
+            ("cache_dir/", None),
+        ]
+    ) as root:
+        cache = DiskCache(root / "cache_dir")
+        file = root / "objects/file1"
+        op_key = bytes.fromhex("abcdef1234567890")
+        original_key = path_key(file)
+
+        assert not cache.has(op_key)
+        cached_file = cache.store_path(op_key, file)
+
+        assert path_key(cached_file) == original_key
+        assert cache.has(op_key)
+
+        retrieved_file = cache.get_path(op_key)
+        assert path_key(retrieved_file) == original_key
+
+
+def test_store_again():
+    with TempFileStructure(
+        [
+            ("objects1/file", "file"),
+            ("objects2/file", "file"),
+            ("cache_dir/", None),
+        ]
+    ) as root:
+        cache = DiskCache(root / "cache_dir")
+        file1 = root / "objects1/file"
+        file2 = root / "objects2/file"
+        op1_key = bytes.fromhex("abcd01")
+        op2_key = bytes.fromhex("abcd02")
+        cached_file1 = cache.store_path(op1_key, file1)
+        cached_file2 = cache.store_path(op2_key, file2)
+
+        assert path_key(cached_file1) == path_key(cached_file2)

fab/lang/astree.py

@@ -0,0 +1,109 @@
+import abc
+from math import exp
+from typing import override
+
+
+class AstNode(abc.ABC):
+    pass
+
+
+class Name(AstNode):
+    name: str
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    @override
+    def __repr__(self) -> str:
+        return f"<Name {self.name}>"
+
+    @override
+    def __str__(self) -> str:
+        return self.name
+
+
+class Expression(AstNode, abc.ABC):
+    pass
+
+
+class LiteralString(Expression):
+    value: str
+
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+    @override
+    def __repr__(self):
+        return f'<LiteralString "{self.value}">'
+
+
+class Call(Expression):
+    target: Expression
+    pos_args: list[Expression]
+    key_args: dict[Name, Expression]
+
+    def __init__(
+        self,
+        target: Expression,
+        pos_args: list[Expression],
+        key_args: dict[Name, Expression],
+    ) -> None:
+        self.target = target
+        self.pos_args = pos_args
+        self.key_args = key_args
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"<Call target={self.target}, args={self.pos_args}, kwargs={self.key_args}>"
+        )
+
+
+class Variable(Expression):
+    name: Name
+
+    def __init__(self, name: Name) -> None:
+        self.name = name
+
+    @override
+    def __repr__(self) -> str:
+        return f"<Variable {self.name}>"
+
+
+class List(Expression):
+    items: list[Expression]
+
+    def __init__(self, items: list[Expression]) -> None:
+        self.items = items
+
+    @override
+    def __repr__(self):
+        return f"<List {','.join((str(x) for x in self.items))}>"
+
+
+class ListComprehension(Expression):
+    expression: Expression
+    target: Name
+    iterable: Expression
+
+    def __init__(self, expression: Expression, target: Name, iterable: Expression):
+        self.expression = expression
+        self.target = target
+        self.iterable = iterable
+
+    @override
+    def __repr__(self) -> str:
+        return f"<ListComprehension ...>"
+
+
+class AttributeRef(Expression):
+    target: Expression
+    name: Name
+
+    def __init__(self, target: Expression, name: Name) -> None:
+        self.target = target
+        self.name = name
+
+    @override
+    def __repr__(self) -> str:
+        return f"<AttributeRef {self.target}.{self.name}>"

fab/lang/buildins.py

@@ -0,0 +1,140 @@
+from copy import copy
+from pathlib import Path
+from typing import override
+
+from fab.operations.gcc import GccCompile, GccLink, GccCollectCompileCommands
+
+from ..operations import Extract, HttpArchive, HttpGet
+from .data import EvaluationContext, Function, List, Object, PathObj, String
+from .evaluator import EvaluationError, evaluate_context
+
+
+class LoadFunc(Function):
+    @override
+    async def call(
+        self, context: EvaluationContext, args: list[Object], kwargs: dict[str, Object]
+    ) -> Object:
+        assert isinstance(args[0], String)
+        filename = Path(args[0].value)
+
+        if filename.is_absolute():
+            raise EvaluationError("Cannot load absolute path")
+
+        new_context = copy(context)
+        new_context.apply_filename(filename)
+
+        return evaluate_context(new_context)
+
+
+class PathFunc(Function):
+    @override
+    async def call(
+        self, context: EvaluationContext, args: list[Object], kwargs: dict[str, Object]
+    ) -> Object:
+        assert isinstance(args[0], String)
+        path_str = args[0].value
+        working_dir = context.get_current_file().parent
+        path = working_dir / path_str
+        if not path.exists():
+            raise EvaluationError(f"No such path '{path_str}' ('{path}')")
+
+        return PathObj(path)
+
+
+class LinkFunc(Function):
+    @override
+    async def call(
+        self, context: EvaluationContext, args: list[Object], kwargs: dict[str, Object]
+    ) -> Object:
+        assert isinstance(args[0], PathObj)
+        target_path = args[0].path
+
+        destination = context.get_current_file().parent
+        link_path = destination / target_path.name
+
+        if link_path.exists():
+            if not link_path.is_symlink():
+                raise EvaluationError(
+                    f"Link target already exists and is not a symlink '{link_path}'"
+                )
+
+            link_path.unlink()
+
+        link_path.symlink_to(target_path)
+
+        return PathObj(link_path)
+
+
+class HttpGetFunc(Function):
+    @override
+    async def call(
+        self, context: EvaluationContext, args: list[Object], kwargs: dict[str, Object]
+    ) -> Object:
+        assert isinstance(args[0], String)
+        url = args[0].value
+        op = HttpGet(url)
+        result = await context.execute_operation(op)
+        return PathObj(result)
+
+
+class ExtractFunc(Function):
+    @override
+    async def call(
+        self, context: EvaluationContext, args: list[Object], kwargs: dict[str, Object]
+    ) -> Object:
+        assert isinstance(args[0], PathObj)
+        archive = args[0].path
+        op = Extract(archive)
+        result = await context.execute_operation(op)
+        return PathObj(result)
+
+
+class HttpArchiveFunc(Function):
+    @override
+    async def call(
+        self, context: EvaluationContext, args: list[Object], kwargs: dict[str, Object]
+    ) -> Object:
+        assert isinstance(args[0], String)
+        url = args[0].value
+        op = HttpArchive(url)
+        result = await context.execute_operation(op)
+        return PathObj(result)
+
+
+class GccCompileFunc(Function):
+    @override
+    async def call(
+        self, context: EvaluationContext, args: list[Object], kwargs: dict[str, Object]
+    ) -> Object:
+        assert isinstance(args[0], PathObj)
+        assert isinstance(kwargs["includes"], List)
+        source = args[0].path
+        includes = [p.path for p in kwargs["includes"].items]
+        op = GccCompile(source, includes)
+        result = await context.execute_operation(op)
+        return PathObj(result)
+
+
+class GccLinkFunc(Function):
+    @override
+    async def call(
+        self, context: EvaluationContext, args: list[Object], kwargs: dict[str, Object]
+    ) -> Object:
+        assert isinstance(args[0], String)
+        assert isinstance(args[1], List)
+        outputname = args[0].value
+        objects = [item.path for item in args[1].items]
+
+        op = GccLink(outputname, objects)
+        result = await context.execute_operation(op)
+        return PathObj(result)
+
+
+class GccCollectCompileCommandsFunc(Function):
+    @override
+    async def call(
+        self, context: EvaluationContext, args: list[Object], kwargs: dict[str, Object]
+    ) -> Object:
+        op = GccCollectCompileCommands()
+        result = await context.execute_operation(op)
+        return PathObj(result)

fab/lang/data.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import pathlib
+from abc import ABC, abstractmethod
+from collections.abc import Mapping, Sequence
+from typing import Any, override
+
+from ..model import Operation
+
+
+class Object(ABC):
+    def has_attr(self, name: str) -> bool:
+        return False
+
+    def attrs(self) -> Sequence[str]:
+        return []
+
+    async def get_attr(self, name: str) -> Object:
+        raise KeyError
+
+    @override
+    def __eq__(self, value: object, /) -> bool:
+        raise NotImplementedError
+
+
+class String(Object):
+    value: str
+
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+    @override
+    def __eq__(self, other: object, /) -> bool:
+        if not isinstance(other, String):
+            return False
+        return self.value == other.value
+
+    @override
+    def __repr__(self) -> str:
+        return f'<String "{self.value}">'
+
+
+class List(Object):
+    items: Sequence[Object]
+
+    def __init__(self, items: Sequence[Object]) -> None:
+        self.items = items
+
+    @override
+    def __eq__(self, other: object, /) -> bool:
+        if not isinstance(other, List):
+            return False
+        return self.items == other.items
+
+
+class PathObj(Object):
+    path: pathlib.Path
+
+    def __init__(self, path: pathlib.Path) -> None:
+        self.path = path
+
+    @override
+    def __eq__(self, other: object, /) -> bool:
+        if not isinstance(other, PathObj):
+            return False
+        return self.path == other.path
+
+
+class EvaluationContext(ABC):
+    @abstractmethod
+    def apply_filename(self, path: pathlib.Path) -> None: ...
+
+    @abstractmethod
+    def get_current_file(self) -> pathlib.Path: ...
+
+    @abstractmethod
+    async def execute_operation(self, operation: Operation) -> Any: ...
+
+    @property
+    @abstractmethod
+    def buildins(self) -> Mapping[str, Object]: ...
+
+
+class Function(Object, ABC):
+    @abstractmethod
+    async def call(
+        self, context: EvaluationContext, args: list[Object], kwargs: dict[str, Object]
+    ) -> Object: ...

fab/lang/evaluator.py

@@ -0,0 +1,119 @@
+from collections.abc import Mapping, Sequence
+from typing import override
+
+from ..lang import astree
+from .data import EvaluationContext, Function, List, Object, String
+from .parser import parse
+
+
+class EvaluationError(RuntimeError):
+    pass
+
+
+def evaluate_context(context: EvaluationContext) -> Object:
+    source = context.get_current_file().read_text()
+
+    assignments = parse(source)
+
+    class LoadedObject(Object):
+        @override
+        def has_attr(self, name: str) -> bool:
+            return name in assignments
+
+        @override
+        async def get_attr(self, name: str) -> Object:
+            expr = assignments[name]
+            return await evaluate(expr, assignments, {}, context)
+
+        @override
+        def attrs(self) -> Sequence[str]:
+            return list(assignments.keys())
+
+    return LoadedObject()
+
+
+async def evaluate(
+    expr: astree.Expression,
+    assignments: Mapping[str, astree.Expression],
+    locals: Mapping[str, Object],
+    context: EvaluationContext,
+) -> Object:
+
+    async def evaluate_variable(expr: astree.Variable) -> Object:
+        var_name = expr.name.name
+        if var_name in locals:
+            return locals[var_name]
+        if var_name in context.buildins:
+            return context.buildins[var_name]
+        if var_name not in assignments:
+            raise EvaluationError(f"No variable named '{var_name}'")
+        return await evaluate(assignments[var_name], assignments, locals, context)
+
+    async def evaluate_literal_string(expr: astree.LiteralString) -> Object:
+        return String(expr.value)
+
+    async def evaluate_list(expr: astree.List) -> Object:
+        evaluated_items = [
+            await evaluate(item, assignments, locals, context) for item in expr.items
+        ]
+        return List(evaluated_items)
+
+    async def evaluate_list_comprehension(expr: astree.ListComprehension) -> Object:
+
+        items = await evaluate(expr.iterable, assignments, locals, context)
+        assert isinstance(items, List)
+
+        evaluated_items = [
+            await evaluate(
+                expr.expression, assignments, {expr.target.name: item}, context
+            )
+            for item in items.items
+        ]
+
+        return List(evaluated_items)
+
+    async def evaluate_attribute_ref(expr: astree.AttributeRef) -> Object:
+        evaluated_target = await evaluate(expr.target, assignments, locals, context)
+        attr_name = expr.name.name
+        if not evaluated_target.has_attr(attr_name):
+            raise EvaluationError(f"No attribute named '{attr_name}'")
+        return await evaluated_target.get_attr(attr_name)
+
+    async def evaluate_call(expr: astree.Call) -> Object:
+        evaluated_target = await evaluate(expr.target, assignments, locals, context)
+        evaluated_args = [
+            await evaluate(arg, assignments, locals, context) for arg in expr.pos_args
+        ]
+        evaluated_kwargs = {
+            kw.name: await evaluate(arg, assignments, locals, context)
+            for kw, arg in expr.key_args.items()
+        }
+
+        if isinstance(evaluated_target, Function):
+            return await evaluate_function_call(
+                evaluated_target, evaluated_args, evaluated_kwargs
+            )
+        else:
+            raise EvaluationError("Target is not a callable")
+
+    async def evaluate_function_call(
+        target: Function,
+        args: list[Object],
+        kwargs: dict[str, Object],
+    ) -> Object:
+        return await target.call(context, args, kwargs)
+
+    if isinstance(expr, astree.Variable):
+        return await evaluate_variable(expr)
+    elif isinstance(expr, astree.LiteralString):
+        return await evaluate_literal_string(expr)
+    elif isinstance(expr, astree.List):
+        return await evaluate_list(expr)
+    elif isinstance(expr, astree.ListComprehension):
+        return await evaluate_list_comprehension(expr)
+    elif isinstance(expr, astree.AttributeRef):
+        return await evaluate_attribute_ref(expr)
+    elif isinstance(expr, astree.Call):
+        return await evaluate_call(expr)
+    else:
+        raise NotImplementedError(f"Handling of {type(expr)} is not implemented")

fab/lang/grammar.lark

@@ -0,0 +1,39 @@
+%import common.CNAME 
+%import common.WS
+%import common.ESCAPED_STRING
+
+COMMENT: /#[^\n]*/
+
+%ignore WS
+%ignore COMMENT
+
+listing: assignment*
+
+string: ESCAPED_STRING
+name: CNAME
+
+assignment: name "=" expression
+
+
+?expression: string 
+           | call
+           | variable
+           | list 
+           | list_comprehension
+           | attributeref 
+
+
+variable: name
+
+list: "[" [expression ("," expression)* [","] ] "]"
+
+list_comprehension: "[" expression "for" name "in" expression "]"
+
+attributeref: expression "." name
+
+call: expression "(" [ call_args ] ")"
+call_args: (arg ("," arg)* ["," kwarg ("," kwarg)* ] [","] ) 
+         | (kwarg ("," kwarg)* [","] ) 
+?arg: expression
+kwarg: name "=" expression
+