lionweb 0.2.0__py3-none-any.whl

lionweb/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.2.0"
+from .lionweb_version import LionWebVersion as LionWebVersion

lionweb/api/classifier_instance_resolver.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from lionweb.api.unresolved_classifier_instance_exception import \
+    UnresolvedClassifierInstanceException
+from lionweb.model.impl.proxy_node import ProxyNode
+
+
+class ClassifierInstanceResolver(ABC):
+
+    @abstractmethod
+    def resolve(self, instance_id: str) -> Optional[Any]:
+        """Return the classifier instance or None if not found."""
+        pass
+
+    def can_resolve(self, instance_id: str) -> bool:
+        """Return True if the instance can be resolved, False otherwise."""
+        return self.resolve(instance_id) is not None
+
+    def strictly_resolve(self, instance_id: str) -> Any:
+        """Return the classifier instance or raise an exception if not found."""
+        instance = self.resolve(instance_id)
+        if instance is None:
+            raise UnresolvedClassifierInstanceException(instance_id)
+        return instance
+
+    def resolve_or_proxy(self, instance_id: str) -> Any:
+        """Return the classifier instance or a ProxyNode if not found."""
+        instance = self.resolve(instance_id)
+        return instance if instance is not None else ProxyNode(instance_id)

lionweb/api/composite_classifier_instance_resolver.py

@@ -0,0 +1,29 @@
+from typing import List, Optional
+
+from lionweb.api.classifier_instance_resolver import ClassifierInstanceResolver
+from lionweb.model import ClassifierInstance
+
+
+class CompositeClassifierInstanceResolver(ClassifierInstanceResolver):
+    def __init__(self, *classifier_instance_resolvers: ClassifierInstanceResolver):
+        self.classifier_instance_resolvers: List[ClassifierInstanceResolver] = list(
+            classifier_instance_resolvers
+        )
+
+    def add(
+        self, classifier_instance_resolver: ClassifierInstanceResolver
+    ) -> "CompositeClassifierInstanceResolver":
+        self.classifier_instance_resolvers.append(classifier_instance_resolver)
+        return self
+
+    def resolve(self, instance_id: str) -> Optional[ClassifierInstance]:
+        for resolver in self.classifier_instance_resolvers:
+            instance = resolver.resolve(instance_id)
+            if instance is not None:
+                return instance
+        return None
+
+    def __str__(self) -> str:
+        return (
+            f"CompositeClassifierInstanceResolver({self.classifier_instance_resolvers})"
+        )

lionweb/api/local_classifier_instance_resolver.py

@@ -0,0 +1,24 @@
+from lionweb.api.classifier_instance_resolver import ClassifierInstanceResolver
+
+
+class LocalClassifierInstanceResolver(ClassifierInstanceResolver):
+    def __init__(self, *instances):
+        self.instances = {instance.id: instance for instance in instances}
+
+    def add(self, instance):
+        self.instances[instance.id] = instance
+
+    def resolve(self, instance_id):
+        return self.instances.get(instance_id)
+
+    def add_all(self, instances):
+        for instance in instances:
+            self.add(instance)
+
+    def add_tree(self, root):
+        self.add(root)
+        for child in root.get_children():
+            self.add_tree(child)
+
+    def __str__(self):
+        return f"LocalClassifierInstanceResolver({list(self.instances.keys())})"

lionweb/api/unresolved_classifier_instance_exception.py

@@ -0,0 +1,8 @@
+class UnresolvedClassifierInstanceException(RuntimeError):
+
+    def __init__(self, instance_id: str):
+        super().__init__("Unable to resolve classifier instance with ID=" + instance_id)
+        self._instance_id = instance_id
+
+    def get_instance_id(self) -> str:
+        return self._instance_id

lionweb/generation/deserializer_generation.py

@@ -0,0 +1,165 @@
+import ast
+from _ast import stmt
+from pathlib import Path
+from typing import List, cast
+
+import astor  # type: ignore
+
+from lionweb.language import Concept, Language
+
+
+def deserializer_generation(click, language: Language, output):
+    module_body = []
+
+    # Import statements
+    module_body.append(
+        ast.ImportFrom(
+            module="gen.language",
+            names=[
+                ast.alias(name=f"get_{cast(str, c.get_name()).lower()}", asname=None)
+                for c in language.get_elements()
+                if isinstance(c, Concept)
+            ],
+            level=0,
+        )
+    )
+    module_body.append(
+        ast.ImportFrom(
+            module="gen.node_classes",
+            names=[
+                ast.alias(name=cast(str, c.get_name()), asname=None)
+                for c in language.get_elements()
+                if isinstance(c, Concept)
+            ],
+            level=0,
+        )
+    )
+    module_body.append(
+        ast.ImportFrom(
+            module="lionweb.serialization",
+            names=[ast.alias(name="AbstractSerialization", asname=None)],
+            level=0,
+        )
+    )
+    module_body.append(
+        ast.ImportFrom(
+            module="lionweb.serialization.data.serialized_classifier_instance",
+            names=[ast.alias(name="SerializedClassifierInstance", asname=None)],
+            level=0,
+        )
+    )
+
+    register_func_body: List[stmt] = []
+    for language_element in language.get_elements():
+        if isinstance(language_element, Concept):
+            concept_name = cast(str, language_element.get_name())
+            # deserializer() inner function
+            register_func_body.append(
+                ast.FunctionDef(
+                    name=f"deserializer_{concept_name.lower()}",
+                    args=ast.arguments(
+                        posonlyargs=[],
+                        args=[
+                            ast.arg(arg="classifier"),
+                            ast.arg(
+                                arg="serialized_instance",
+                                annotation=ast.Name(
+                                    id="SerializedClassifierInstance", ctx=ast.Load()
+                                ),
+                            ),
+                            ast.arg(arg="deserialized_instances_by_id"),
+                            ast.arg(arg="properties_values"),
+                        ],
+                        kwonlyargs=[],
+                        kw_defaults=[],
+                        defaults=[],
+                    ),
+                    body=[
+                        ast.Return(
+                            value=ast.Call(
+                                func=ast.Name(id=concept_name, ctx=ast.Load()),
+                                args=[
+                                    ast.Attribute(
+                                        value=ast.Name(
+                                            id="serialized_instance", ctx=ast.Load()
+                                        ),
+                                        attr="id",
+                                        ctx=ast.Load(),
+                                    )
+                                ],
+                                keywords=[],
+                            )
+                        )
+                    ],
+                    decorator_list=[],
+                    returns=None,
+                )
+            )
+
+            # register_deserializers() function
+            register_func_body.append(
+                ast.Expr(
+                    value=ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Attribute(
+                                value=ast.Name(id="serialization", ctx=ast.Load()),
+                                attr="instantiator",
+                                ctx=ast.Load(),
+                            ),
+                            attr="register_custom_deserializer",
+                            ctx=ast.Load(),
+                        ),
+                        args=[
+                            ast.Attribute(
+                                value=ast.Call(
+                                    func=ast.Name(
+                                        id=f"get_{concept_name.lower()}", ctx=ast.Load()
+                                    ),
+                                    args=[],
+                                    keywords=[],
+                                ),
+                                attr="id",
+                                ctx=ast.Load(),
+                            )
+                        ],
+                        keywords=[
+                            ast.keyword(
+                                arg="deserializer",
+                                value=ast.Name(
+                                    id=f"deserializer_{concept_name.lower()}",
+                                    ctx=ast.Load(),
+                                ),
+                            )
+                        ],
+                    )
+                )
+            )
+
+    register_func = ast.FunctionDef(
+        name="register_deserializers",
+        args=ast.arguments(
+            posonlyargs=[],
+            args=[
+                ast.arg(
+                    arg="serialization",
+                    annotation=ast.Name(id="AbstractSerialization", ctx=ast.Load()),
+                )
+            ],
+            kwonlyargs=[],
+            kw_defaults=[],
+            defaults=[],
+        ),
+        body=register_func_body,
+        decorator_list=[],
+        returns=None,
+    )
+
+    # Final module
+    module = ast.Module(body=module_body + [register_func], type_ignores=[])
+
+    generated_code = astor.to_source(module)
+    output_path = Path(output)
+    output_path.mkdir(parents=True, exist_ok=True)
+    click.echo(f"📂 Saving deserializer to: {output}")
+    with Path(f"{output}/deserializer.py").open("w", encoding="utf-8") as f:
+        f.write(generated_code)

lionweb/generation/generator.py

@@ -0,0 +1,54 @@
+from typing import cast
+
+import click
+
+from lionweb.generation.language_generation import language_generation
+from lionweb.language import Language
+from lionweb.lionweb_version import LionWebVersion
+from lionweb.serialization.serialization_provider import SerializationProvider
+
+
+@click.command()
+@click.option(
+    "-d",
+    "--dependencies",
+    type=click.Path(exists=True, dir_okay=False, readable=True),
+    multiple=True,
+)
+@click.argument(
+    "lionweb-language", type=click.Path(exists=True, dir_okay=False, readable=True)
+)
+@click.argument("output", type=click.Path(exists=False, file_okay=False, writable=True))
+def main(dependencies, lionweb_language, output):
+    from lionweb.generation.deserializer_generation import \
+        deserializer_generation
+    from lionweb.generation.node_classes_generation import \
+        node_classes_generation
+
+    """Simple CLI that processes a file and writes results to a directory."""
+    serialization = SerializationProvider.get_standard_json_serialization(
+        LionWebVersion.V2023_1
+    )
+
+    for dep in dependencies:
+        click.echo(f"Processing dependency {dep}")
+        with open(dep, "r", encoding="utf-8") as f:
+            content = f.read()
+            language = cast(
+                Language, serialization.deserialize_string_to_nodes(content)[0]
+            )
+            serialization.register_language(language=language)
+            serialization.classifier_resolver.register_language(language)
+            serialization.instance_resolver.add_tree(language)
+
+    click.echo(f"📄 Processing file: {lionweb_language}")
+    with open(lionweb_language, "r", encoding="utf-8") as f:
+        content = f.read()
+        language = cast(Language, serialization.deserialize_string_to_nodes(content)[0])
+    language_generation(click, language, output)
+    node_classes_generation(click, language, output)
+    deserializer_generation(click, language, output)
+
+
+if __name__ == "__main__":
+    main()

lionweb/generation/language_generation.py

@@ -0,0 +1,332 @@
+import ast
+from _ast import expr, stmt
+from pathlib import Path
+from typing import List, cast
+
+import astor  # type: ignore
+
+from lionweb.language import (Concept, Containment, DataType, Language,
+                              LionCoreBuiltins, Property)
+from lionweb.language.reference import Reference
+
+
+def _set_lw_version(language: Language):
+    return ast.keyword(
+        arg="lion_web_version",
+        value=ast.Attribute(
+            value=ast.Name(id="LionWebVersion", ctx=ast.Load()),
+            attr=language.get_lionweb_version().name,
+            ctx=ast.Load(),
+        ),
+    )
+
+
+def _generate_language(language: Language) -> ast.Assign:
+    return ast.Assign(
+        targets=[ast.Name(id="language", ctx=ast.Store())],
+        value=ast.Call(
+            func=ast.Name(id="Language", ctx=ast.Load()),
+            args=[],
+            keywords=[
+                _set_lw_version(language),
+                ast.keyword(arg="id", value=ast.Constant(value=language.id)),
+                ast.keyword(arg="name", value=ast.Constant(value=language.get_name())),
+                ast.keyword(arg="key", value=ast.Constant(value=language.key)),
+                ast.keyword(
+                    arg="version", value=ast.Constant(value=language.get_version())
+                ),
+            ],
+        ),
+    )
+
+
+def language_generation(click, language: Language, output):
+    body: List[stmt] = []
+    body.append(
+        ast.ImportFrom(
+            module="lionweb.language",
+            names=[
+                ast.alias(name="Language", asname=None),
+                ast.alias(name="Concept", asname=None),
+                ast.alias(name="Property", asname=None),
+                ast.alias(name="Containment", asname=None),
+                ast.alias(name="Reference", asname=None),
+                ast.alias(name="LionCoreBuiltins", asname=None),
+            ],
+            level=0,
+        )
+    )
+    body.append(
+        ast.ImportFrom(
+            module="lionweb.lionweb_version",
+            names=[ast.alias(name="LionWebVersion", asname=None)],
+            level=0,
+        )
+    )
+    body.append(
+        ast.ImportFrom(
+            module="functools",
+            names=[ast.alias(name="lru_cache", asname=None)],
+            level=0,
+        )
+    )
+    # Decorator: @lru_cache(maxsize=1)
+    decorator = ast.Call(
+        func=ast.Name(id="lru_cache", ctx=ast.Load()),
+        args=[],
+        keywords=[ast.keyword(arg="maxsize", value=ast.Constant(value=1))],
+    )
+
+    # Function body for get_language()
+    function_body: List[stmt] = []
+    function_body.append(_generate_language(language))
+
+    for language_element in language.get_elements():
+        if isinstance(language_element, Concept):
+            concept_name = cast(str, language_element.get_name())
+            function_body.append(
+                ast.Assign(
+                    targets=[ast.Name(id=concept_name, ctx=ast.Store())],
+                    value=ast.Call(
+                        func=ast.Name(id="Concept", ctx=ast.Load()),
+                        args=[],
+                        keywords=[
+                            _set_lw_version(language),
+                            ast.keyword(
+                                arg="id", value=ast.Constant(value=language_element.id)
+                            ),
+                            ast.keyword(
+                                arg="name", value=ast.Constant(value=concept_name)
+                            ),
+                            ast.keyword(
+                                arg="key",
+                                value=ast.Constant(value=language_element.key),
+                            ),
+                        ],
+                    ),
+                )
+            )
+
+            if language_element.get_extended_concept():
+                ec = cast(Concept, language_element.get_extended_concept())
+                ec_name = cast(str, ec.get_name())
+                function_body.append(
+                    ast.Expr(
+                        ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id=concept_name, ctx=ast.Load()),
+                                attr="set_extended_concept",
+                                ctx=ast.Load(),
+                            ),
+                            args=[ast.Name(id=ec_name, ctx=ast.Load())],
+                            keywords=[],
+                        )
+                    )
+                )
+
+            for interf in language_element.get_implemented():
+                function_body.append(
+                    ast.Expr(
+                        ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id=concept_name, ctx=ast.Load()),
+                                attr="add_implemented",
+                                ctx=ast.Load(),
+                            ),
+                            args=[],
+                            keywords=[],
+                        )
+                    )
+                )
+
+            # language.add_element(concept1)
+            function_body.append(
+                ast.Expr(
+                    value=ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Name(id="language", ctx=ast.Load()),
+                            attr="add_element",
+                            ctx=ast.Load(),
+                        ),
+                        args=[ast.Name(id=concept_name, ctx=ast.Load())],
+                        keywords=[],
+                    )
+                )
+            )
+
+            for feature in language_element.get_features():
+                if isinstance(feature, Reference):
+                    feature_creation = ast.Call(
+                        func=ast.Name(id="Reference", ctx=ast.Load()),
+                        args=[],
+                        keywords=[
+                            _set_lw_version(language),
+                            ast.keyword(arg="id", value=ast.Constant(value=feature.id)),
+                            ast.keyword(
+                                arg="name", value=ast.Constant(value=feature.get_name())
+                            ),
+                            ast.keyword(
+                                arg="key", value=ast.Constant(value=feature.key)
+                            ),
+                        ],
+                    )
+                    function_body.append(
+                        ast.Expr(
+                            value=ast.Call(
+                                func=ast.Attribute(
+                                    value=ast.Name(id=concept_name, ctx=ast.Load()),
+                                    attr="add_feature",
+                                    ctx=ast.Load(),
+                                ),
+                                args=[feature_creation],
+                                keywords=[],
+                            )
+                        )
+                    )
+                elif isinstance(feature, Property):
+                    pt = cast(DataType, feature.type)
+                    property_type: expr
+                    if pt == LionCoreBuiltins.get_string(feature.lion_web_version):
+                        property_type = ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id="LionCoreBuiltins", ctx=ast.Load()),
+                                attr="get_string",
+                                ctx=ast.Load(),
+                            ),
+                            args=[],
+                            keywords=[_set_lw_version(language)],
+                        )
+                    elif pt == LionCoreBuiltins.get_integer(feature.lion_web_version):
+                        property_type = ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id="LionCoreBuiltins", ctx=ast.Load()),
+                                attr="get_integer",
+                                ctx=ast.Load(),
+                            ),
+                            args=[],
+                            keywords=[_set_lw_version(language)],
+                        )
+                    else:
+                        raise ValueError(cast(str, pt.get_name()))
+                    feature_creation = ast.Call(
+                        func=ast.Name(id="Property", ctx=ast.Load()),
+                        args=[],
+                        keywords=[
+                            _set_lw_version(language),
+                            ast.keyword(arg="id", value=ast.Constant(value=feature.id)),
+                            ast.keyword(
+                                arg="name", value=ast.Constant(value=feature.get_name())
+                            ),
+                            ast.keyword(
+                                arg="key", value=ast.Constant(value=feature.key)
+                            ),
+                            ast.keyword(arg="type", value=property_type),
+                        ],
+                    )
+                    function_body.append(
+                        ast.Expr(
+                            value=ast.Call(
+                                func=ast.Attribute(
+                                    value=ast.Name(id=concept_name, ctx=ast.Load()),
+                                    attr="add_feature",
+                                    ctx=ast.Load(),
+                                ),
+                                args=[feature_creation],
+                                keywords=[],
+                            )
+                        )
+                    )
+                elif isinstance(feature, Containment):
+                    feature_creation = ast.Call(
+                        func=ast.Name(id="Containment", ctx=ast.Load()),
+                        args=[],
+                        keywords=[
+                            _set_lw_version(language),
+                            ast.keyword(arg="id", value=ast.Constant(value=feature.id)),
+                            ast.keyword(
+                                arg="name", value=ast.Constant(value=feature.get_name())
+                            ),
+                            ast.keyword(
+                                arg="key", value=ast.Constant(value=feature.key)
+                            ),
+                        ],
+                    )
+                    function_body.append(
+                        ast.Expr(
+                            value=ast.Call(
+                                func=ast.Attribute(
+                                    value=ast.Name(id=concept_name, ctx=ast.Load()),
+                                    attr="add_feature",
+                                    ctx=ast.Load(),
+                                ),
+                                args=[feature_creation],
+                                keywords=[],
+                            )
+                        )
+                    )
+
+    # return language
+    function_body.append(ast.Return(value=ast.Name(id="language", ctx=ast.Load())))
+
+    # Define get_language function
+    get_language_def = ast.FunctionDef(
+        name="get_language",
+        args=ast.arguments(
+            posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]
+        ),
+        body=function_body,
+        decorator_list=[decorator],
+        returns=ast.Name(id="Language", ctx=ast.Load()),
+        type_comment=None,
+    )
+
+    # Wrap function in module
+    body.append(get_language_def)
+
+    for language_element in language.get_elements():
+        if isinstance(language_element, Concept):
+            concept_name = cast(str, language_element.get_name())
+            body.append(
+                ast.FunctionDef(
+                    name=f"get_{concept_name.lower()}",
+                    args=ast.arguments(
+                        posonlyargs=[],
+                        args=[],
+                        kwonlyargs=[],
+                        kw_defaults=[],
+                        defaults=[],
+                    ),
+                    body=[
+                        ast.Return(
+                            value=ast.Call(
+                                func=ast.Attribute(
+                                    value=ast.Call(
+                                        func=ast.Name(
+                                            id="get_language", ctx=ast.Load()
+                                        ),
+                                        args=[],
+                                        keywords=[],
+                                    ),
+                                    attr="get_concept_by_name",
+                                    ctx=ast.Load(),
+                                ),
+                                args=[ast.Constant(value=language_element.get_name())],
+                                keywords=[],
+                            )
+                        )
+                    ],
+                    decorator_list=[],
+                    returns=ast.Name(id="Concept", ctx=ast.Load()),
+                    type_comment=None,
+                )
+            )
+
+    module = ast.Module(body=body, type_ignores=[])
+
+    click.echo(f"📂 Saving language to: {output}")
+    generated_code = astor.to_source(module)
+    output_path = Path(output)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    with Path(f"{output}/language.py").open("w", encoding="utf-8") as f:
+        f.write(generated_code)