aegis-core 1.5.2__tar.gz

aegis_core-1.5.2/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.3
+Name: aegis_core
+Version: 1.5.2
+Summary: A library to manipulate Mecha for language server usage
+License: MIT
+Author: TheNuclearNexus
+Author-email: 39636175+TheNuclearNexus@users.noreply.github.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: bolt (>=0.49.1,<0.50.0)
+Requires-Dist: lsprotocol (>=2023.0.1,<2024.0.0)
+Requires-Dist: mecha (>=0.96.0,<0.97.0)
+Description-Content-Type: text/markdown
+
+# Aegis Core

aegis_core-1.5.2/README.md

@@ -0,0 +1 @@
+# Aegis Core

aegis_core-1.5.2/aegis_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.0"

aegis_core-1.5.2/aegis_core/ast/features/__init__.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass, field
+
+from beet import Context
+from bolt import AstAttribute, AstIdentifier, AstImportedItem, AstTargetIdentifier
+from mecha import AstNode, AstResourceLocation
+
+from .provider import *
+from .resource_location import *
+from .variable import *
+
+
+def get_default_providers() -> dict[type[AstNode], type[BaseFeatureProvider]]:
+    return {
+        AstIdentifier: VariableFeatureProvider,
+        AstAttribute: VariableFeatureProvider,
+        AstTargetIdentifier: VariableFeatureProvider,
+        AstImportedItem: VariableFeatureProvider,
+        AstResourceLocation: ResourceLocationFeatureProvider,
+    }
+
+
+@dataclass
+class AegisFeatureProviders:
+    ctx: Context
+    _providers: dict[type[AstNode], type[BaseFeatureProvider]] = field(
+        init=False, default_factory=get_default_providers
+    )
+
+    def attach(self, node_type: type[AstNode], provider: type[BaseFeatureProvider]):
+        self._providers[node_type] = provider
+
+    def retrieve(
+        self,
+        node_type: type[AstNode] | AstNode,
+    ) -> type[BaseFeatureProvider]:
+        if not isinstance(node_type, type):
+            node_type = type(node_type)
+
+        return self._providers.get(node_type, BaseFeatureProvider)

aegis_core-1.5.2/aegis_core/ast/features/provider.py

@@ -0,0 +1,85 @@
+from dataclasses import dataclass, field
+from typing import Generic, TypeVar
+
+import lsprotocol.types as lsp
+from beet import Context
+from mecha import AstNode
+
+from ...semantics import TokenModifier, TokenType
+
+__all__ = [
+    "BaseFeatureProvider",
+    "BaseParams",
+    "CompletionParams",
+    "HoverParams",
+    "DefinitionParams",
+    "ReferencesParams",
+    "RenameParams",
+    "SemanticsParams",
+]
+
+Node = TypeVar("Node", bound=AstNode)
+
+
+@dataclass
+class BaseParams(Generic[Node]):
+    ctx: Context
+    node: Node
+
+
+@dataclass
+class CompletionParams(BaseParams[Node]): ...
+
+
+@dataclass
+class HoverParams(BaseParams[Node]):
+    text_range: lsp.Range
+
+
+@dataclass
+class DefinitionParams(BaseParams[Node]): ...
+
+
+@dataclass
+class ReferencesParams(BaseParams[Node]): ...
+
+
+@dataclass
+class RenameParams(BaseParams[Node]): ...
+
+
+@dataclass
+class SemanticsParams(BaseParams[Node]): ...
+
+
+class BaseFeatureProvider(Generic[Node]):
+
+    @classmethod
+    def completion(
+        cls, params: CompletionParams[Node]
+    ) -> list[lsp.CompletionItem] | None:
+        return None
+
+    @classmethod
+    def hover(cls, params: HoverParams[Node]) -> lsp.Hover | None:
+        return None
+
+    @classmethod
+    def definition(
+        cls, params: DefinitionParams[Node]
+    ) -> list[lsp.Location | lsp.LocationLink] | lsp.Location | lsp.LocationLink | None:
+        return None
+
+    @classmethod
+    def references(cls, params: ReferencesParams[Node]) -> list[lsp.Location] | None:
+        return None
+
+    @classmethod
+    def rename(cls, params: RenameParams[Node]) -> lsp.WorkspaceEdit | None:
+        return None
+
+    @classmethod
+    def semantics(
+        cls, params: SemanticsParams[Node]
+    ) -> list[tuple[AstNode, TokenType, TokenModifier]] | None:
+        return None

aegis_core-1.5.2/aegis_core/ast/features/resource_location.py

@@ -0,0 +1,199 @@
+__all__ = ["ResourceLocationFeatureProvider"]
+
+import logging
+from pathlib import Path
+from typing import cast
+
+import lsprotocol.types as lsp
+from beet import File, NamespaceFile
+from mecha import AstResourceLocation
+
+from aegis_core.registry import AegisGameRegistries
+
+from ...ast.helpers import node_location_to_range
+from ...ast.metadata import ResourceLocationMetadata, retrieve_metadata
+from ...indexing.project_index import AegisProjectIndex
+from .provider import BaseFeatureProvider
+
+
+def add_registry_items(
+    registries: AegisGameRegistries,
+    represents: str,
+    prefix: str = "",
+    kind: lsp.CompletionItemKind = lsp.CompletionItemKind.Value,
+):
+    if represents in registries:
+        registry_items = registries[represents]
+
+        return [
+            lsp.CompletionItem(prefix + "minecraft:" + k, kind=kind, sort_text=k)
+            for k in registry_items
+        ]
+
+    return []
+
+
+def get_path(path: str) -> tuple[str | None, Path]:
+    segments = path.split(":")
+    if len(segments) == 1:
+        return (None, Path(segments[0]))
+    else:
+        return (segments[0], Path(segments[1]))
+
+
+class ResourceLocationFeatureProvider(BaseFeatureProvider[AstResourceLocation]):
+    @classmethod
+    def hover(cls, params) -> lsp.Hover | None:
+        node = params.node
+        text_range = params.text_range
+
+        metadata = retrieve_metadata(node, ResourceLocationMetadata)
+
+        if metadata is None or metadata.represents is None:
+            path_type = None
+        elif isinstance(metadata.represents, str):
+            path_type = metadata.represents
+        elif issubclass(metadata.represents, File):
+            path_type = metadata.represents.snake_name
+
+        type_line = f"**{path_type}**\n" if path_type else ""
+
+        return lsp.Hover(
+            lsp.MarkupContent(
+                lsp.MarkupKind.Markdown,
+                f"{type_line}```yaml\n{node.get_canonical_value()}\n```",
+            ),
+            text_range,
+        )
+
+    @classmethod
+    def definition(cls, params):
+        project_index = params.ctx.inject(AegisProjectIndex)
+        node = params.node
+
+        metadata = retrieve_metadata(node, ResourceLocationMetadata)
+
+        if not metadata or not metadata.represents:
+            return
+
+        if isinstance(metadata.represents, str):
+            return
+
+        path = node.get_canonical_value()
+        definitions = project_index[metadata.represents].get_definitions(path)
+
+        return [
+            lsp.LocationLink(
+                target_uri=Path(path).as_uri(),
+                target_range=node_location_to_range(location),
+                target_selection_range=node_location_to_range(location),
+                origin_selection_range=node_location_to_range(node),
+            )
+            for path, *location in definitions
+        ]
+
+    @classmethod
+    def references(cls, params) -> list[lsp.Location] | None:
+        project_index = params.ctx.inject(AegisProjectIndex)
+        node = params.node
+
+        metadata = retrieve_metadata(node, ResourceLocationMetadata)
+
+        if not metadata or not metadata.represents:
+            return
+
+        if isinstance(metadata.represents, str):
+            return
+
+        path = node.get_canonical_value()
+        references = project_index[metadata.represents].get_references(path)
+
+        return [
+            lsp.Location(Path(path).as_uri(), node_location_to_range(location))
+            for path, *location in references
+        ]
+
+    @classmethod
+    def completion(cls, params):
+        node = params.node
+        project_index = params.ctx.inject(AegisProjectIndex)
+
+        metadata = retrieve_metadata(node, ResourceLocationMetadata)
+
+        if not metadata or metadata.represents is not type[NamespaceFile]:
+            return
+
+        represents = metadata.represents
+
+        if represents is type[NamespaceFile]:
+            file_type = cast(type[NamespaceFile], represents)
+
+            path = node.get_canonical_value()
+
+            if node.is_tag:
+                path = path[1:]
+
+            resolved = get_path(path)
+
+            unresolved = get_path(metadata.unresolved_path or path)
+
+            if unresolved[1].name == "~":
+                resolved_parent = resolved[1]
+                unresolved_parent = unresolved[1]
+            else:
+                resolved_parent = resolved[1].parent
+                unresolved_parent = unresolved[1].parent
+
+            items = []
+
+            for file in project_index[file_type]:
+                file_path = get_path(file)
+
+                if not (
+                    file_path[0] == resolved[0]
+                    and file_path[1].is_relative_to(resolved_parent)
+                ):
+                    continue
+
+                relative = file_path[1].relative_to(resolved_parent)
+
+                if unresolved[0] is None and unresolved[1].name == "":
+                    new_path = "./" + str(relative)
+                else:
+                    new_path = str(unresolved_parent / relative)
+
+                insert_text = (
+                    f"{unresolved[0] + ':' if unresolved[0] else ''}{new_path}"
+                )
+                if node.is_tag:
+                    insert_text = "#" + insert_text
+
+                items.append(
+                    lsp.CompletionItem(
+                        label=insert_text,
+                        documentation=file,
+                        text_edit=lsp.InsertReplaceEdit(
+                            insert_text,
+                            node_location_to_range(node),
+                            node_location_to_range(node),
+                        ),
+                    )
+                )
+
+                return items
+
+        elif isinstance(represents, str):
+            registries = params.ctx.inject(AegisGameRegistries)
+            items = []
+
+            items.extend(add_registry_items(registries, represents))
+            items.extend(
+                add_registry_items(
+                    registries,
+                    "tag/" + represents,
+                    "#",
+                    lsp.CompletionItemKind.Constant,
+                )
+            )
+
+            return items

aegis_core-1.5.2/aegis_core/ast/features/variable.py

@@ -0,0 +1,44 @@
+import lsprotocol.types as lsp
+from bolt import AstAttribute, AstIdentifier, AstImportedItem, AstTargetIdentifier
+
+from ...reflection import get_annotation_description
+from ..metadata import VariableMetadata, retrieve_metadata
+from . import BaseFeatureProvider
+
+__all__ = ["VariableFeatureProvider"]
+
+
+class VariableFeatureProvider(
+    BaseFeatureProvider[
+        AstIdentifier | AstAttribute | AstTargetIdentifier | AstImportedItem
+    ]
+):
+    @classmethod
+    def hover(cls, params) -> lsp.Hover | None:
+        node = params.node
+        text_range = params.text_range
+
+        metadata = retrieve_metadata(node, VariableMetadata)
+        name = (
+            node.value
+            if not isinstance(node, (AstAttribute, AstImportedItem))
+            else node.name
+        )
+
+        if metadata and metadata.type_annotation:
+
+            type_annotation = metadata.type_annotation
+
+            description = get_annotation_description(name, type_annotation)
+
+            return lsp.Hover(
+                lsp.MarkupContent(lsp.MarkupKind.Markdown, description), text_range
+            )
+
+        return lsp.Hover(
+            lsp.MarkupContent(
+                lsp.MarkupKind.Markdown,
+                f"```python\n(variable) {name}\n```",
+            ),
+            text_range,
+        )

aegis_core-1.5.2/aegis_core/ast/helpers.py

@@ -0,0 +1,31 @@
+from typing import Iterable
+
+import lsprotocol.types as lsp
+from mecha import AstNode
+from tokenstream import SourceLocation
+
+
+def node_location_to_range(node: AstNode | Iterable[SourceLocation]):
+    if isinstance(node, AstNode):
+        location = node.location
+        end_location = node.end_location
+    else:
+        location, end_location = node
+
+    return lsp.Range(
+        start=location_to_position(location), end=location_to_position(end_location)
+    )
+
+
+def node_start_to_range(node: AstNode):
+    start = location_to_position(node.location)
+    end = lsp.Position(line=start.line, character=start.character + 1)
+
+    return lsp.Range(start=start, end=end)
+
+
+def location_to_position(location: SourceLocation) -> lsp.Position:
+    return lsp.Position(
+        line=max(location.lineno - 1, 0),
+        character=max(location.colno - 1, 0),
+    )

aegis_core-1.5.2/aegis_core/ast/metadata.py

@@ -0,0 +1,107 @@
+from dataclasses import dataclass, field
+from typing import Any, TypeVar
+
+from beet import NamespaceFile
+from mecha import AstNode
+
+from ..reflection import UNKNOWN_TYPE
+
+METADATA_KEY = "aegis_metadata"
+
+__all__ = [
+    "BaseMetadata",
+    "VariableMetadata",
+    "ResourceLocationMetadata",
+    "attach_metadata",
+    "retrieve_metadata",
+]
+
+
+@dataclass
+class BaseMetadata:
+    """
+    BaseMetadata provides information to aegis_server about the AstNode.
+    """
+
+
+@dataclass
+class VariableMetadata(BaseMetadata):
+    """
+    VariableMetadata provides information to aegis_server about a node representing a Bolt variable
+
+    Attributes
+    ----------
+    type_annotation : Any
+        The python type that the node represents
+
+    documentation : str
+        The documentation string for the node
+    """
+
+    type_annotation: Any = field(default=UNKNOWN_TYPE)
+
+    documentation: str | None = field(default=None)
+
+
+@dataclass
+class ResourceLocationMetadata(BaseMetadata):
+    """
+    ResourceLocationMetadata provides information to aegis_server about a node representing a resource location node
+
+    Attributes
+    ----------
+    respresents : str | type[NamespaceFile] | None
+        The registry or type of File the resource location represents
+
+    unresolved_path : str | None
+        The unresolved path of the string, ex. ~/foo
+    """
+
+    represents: str | type[NamespaceFile] | None = field(default=None)
+
+    unresolved_path: str | None = field(default=None)
+
+
+def attach_metadata(node: AstNode, metadata: BaseMetadata):
+    """
+    Attaches the provided metadata instance to the node
+
+    Parameters
+    ----------
+    node : AstNode
+        The node to attach the metadata too
+    metadata : BaseMetadata
+        The metadata to be attached
+    """
+    node.__dict__[METADATA_KEY] = metadata
+
+
+T = TypeVar("T")
+
+
+def retrieve_metadata(
+    node: AstNode, type: tuple[type[T]] | type[T] = BaseMetadata
+) -> T | None:
+    """
+    Retrieves the metadata attached to a node
+
+    Parameters
+    ----------
+    node : AstNode
+        The node to retrieve from
+    type : tuple[type] | type
+        The type to check the metadata for
+
+    Returns
+    -------
+    BaseMetadata
+        The metadata attached to the node
+    None
+        If not metadata is present on the node
+    """
+    metadata = node.__dict__.get(METADATA_KEY)
+
+    if isinstance(metadata, type):
+        return metadata
+
+    return None

aegis_core-1.5.2/aegis_core/indexing/__init__.py

@@ -0,0 +1 @@
+from .project_index import *

aegis_core-1.5.2/aegis_core/indexing/project_index.py

@@ -0,0 +1,170 @@
+import logging
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from threading import Lock
+from typing import ClassVar
+
+from beet import Context, File, NamespaceFile
+from beet.core.utils import extra_field, required_field
+from tokenstream import SourceLocation
+
+__all__ = ["FilePointer", "ResourceIndex", "AegisProjectIndex"]
+
+FilePointer = tuple[SourceLocation, SourceLocation]
+
+
+@dataclass
+class ResourceIndice:
+    definitions: dict[str, set[FilePointer]] = extra_field(default_factory=dict)
+    references: dict[str, set[FilePointer]] = extra_field(default_factory=dict)
+
+    def _dump(self) -> str:
+        dump = ""
+
+        dump += "definitions:\n"
+        for path, pointers in self.definitions.items():
+            for pointer in pointers:
+                dump += f"\t- {path} {pointer[0].lineno}:{pointer[0].colno} -> {pointer[1].lineno}:{pointer[1].colno}\n"
+        dump += "references:\n"
+        for path, pointers in self.references.items():
+            for pointer in pointers:
+                dump += f"\t- {path} {pointer[0].lineno}:{pointer[0].colno} -> {pointer[1].lineno}:{pointer[1].colno}\n"
+
+        return dump
+
+
+def valid_resource_location(path: str):
+    return bool(re.match(r"^[a-z0-9_\.]+:[a-z0-9_\.]+(\/?[a-z0-9_\.]+)*$", path))
+
+
+@dataclass
+class ResourceIndex:
+    _files: dict[str, ResourceIndice] = extra_field(default_factory=dict)
+    _lock: Lock = extra_field(default_factory=Lock)
+
+    def remove_associated(self, path: str | File):
+        self._lock.acquire()
+
+        if isinstance(path, File):
+            path = str(Path(path.ensure_source_path()).absolute())
+
+        for file, indice in list(self._files.items()):
+            if path in indice.definitions:
+                del indice.definitions[path]
+            if path in indice.references:
+                del indice.references[path]
+
+            if len(indice.definitions) == 0:
+                del self._files[file]
+
+        self._lock.release()
+
+    def add_definition(
+        self,
+        resource_path: str,
+        source_path: str,
+        source_location: FilePointer = (
+            SourceLocation(0, 0, 0),
+            SourceLocation(0, 0, 0),
+        ),
+    ):
+        if not valid_resource_location(resource_path):
+            raise Exception(f"Invalid resource location {resource_path}")
+
+        self._lock.acquire()
+
+        indice = self._files.setdefault(resource_path, ResourceIndice())
+        locations = indice.definitions.setdefault(source_path, set())
+        locations.add(source_location)
+
+        self._lock.release()
+
+    def get_definitions(
+        self, resource_path: str
+    ) -> list[tuple[str, SourceLocation, SourceLocation]]:
+        if not (file := self._files.get(resource_path)):
+            return []
+
+        definitions = []
+        for path, locations in file.definitions.items():
+            for location in locations:
+                definitions.append((path, *location))
+
+        return definitions
+
+    def get_references(
+        self, resource_path: str
+    ) -> list[tuple[str, SourceLocation, SourceLocation]]:
+        if not (file := self._files.get(resource_path)):
+            return []
+
+        references = []
+        for path, locations in file.references.items():
+            for location in locations:
+                references.append((path, *location))
+
+        return references
+
+    def add_reference(
+        self,
+        resource_path: str,
+        source_path: str,
+        source_location: FilePointer = (
+            SourceLocation(0, 0, 0),
+            SourceLocation(0, 0, 0),
+        ),
+    ):
+        if not valid_resource_location(resource_path):
+            raise Exception(f"Invalid resource location {resource_path}")
+
+        self._lock.acquire()
+
+        indice = self._files.setdefault(resource_path, ResourceIndice())
+        locations = indice.references.setdefault(source_path, set())
+        locations.add(source_location)
+
+        self._lock.release()
+
+    def __iter__(self):
+        items = self._files.keys()
+
+        for item in items:
+            yield item
+
+    def _dump(self) -> str:
+        dump = ""
+
+        for file, indice in self._files.items():
+            dump += f"\n- '{file}':\n"
+            dump += "\t" + "\n\t".join(indice._dump().splitlines())
+
+        return dump
+
+
+@dataclass
+class AegisProjectIndex:
+    _ctx: Context
+    _resources: dict[type[NamespaceFile], ResourceIndex] = field(default_factory=dict)
+
+    resource_name_to_type: dict[str, type[NamespaceFile]] = field(default_factory=dict)
+
+    def __post_init__(self):
+        self.resource_name_to_type = {
+            t.snake_name: t for t in self._ctx.get_file_types()
+        }
+
+    def __getitem__(self, key: type[NamespaceFile]):
+        return self._resources.setdefault(key, ResourceIndex())
+
+    def remove_associated(self, path: str):
+        for resource in self._resources.values():
+            resource.remove_associated(path)
+
+    def dump(self) -> str:
+        dump = ""
+        for resource, index in self._resources.items():
+            dump += f"\nResource {resource.__name__}:"
+            dump += "\t" + "\n\t".join(index._dump().splitlines())
+
+        return dump

aegis_core-1.5.2/aegis_core/reflection/__init__.py

@@ -0,0 +1,258 @@
+import inspect
+import types
+import typing
+from copy import copy
+from dataclasses import dataclass, field, fields, is_dataclass
+from typing import Any, get_args, get_origin
+
+UNKNOWN_TYPE = object()
+TYPE_TO_INFO: dict[type, "TypeInfo"] = {}
+
+
+@dataclass
+class ParameterInfo:
+    annotation: Any
+    default: Any
+
+
+@dataclass
+class FunctionInfo:
+    parameters: list[tuple[str, ParameterInfo]]
+    return_annotation: Any
+    doc: str | None
+
+    @staticmethod
+    def from_signature(
+        signature: inspect.Signature, doc: str | None, hints: dict[str, Any]
+    ) -> "FunctionInfo":
+        return FunctionInfo(
+            parameters=[
+                (
+                    name,
+                    ParameterInfo(
+                        annotation=parameter.annotation, default=parameter.default
+                    ),
+                )
+                for name, parameter in signature.parameters.items()
+            ],
+            return_annotation=hints.get("return") or signature.return_annotation,
+            doc=doc,
+        )
+
+    @staticmethod
+    def extract(field_value: Any):
+        try:
+            hints = typing.get_type_hints(field_value)
+            signature = inspect.signature(field_value)
+            return FunctionInfo.from_signature(signature, field_value.__doc__, hints)
+        except Exception as e:
+            return FunctionInfo(
+                parameters=[
+                    (
+                        "???",
+                        ParameterInfo(inspect.Parameter.empty, inspect.Parameter.empty),
+                    )
+                ],
+                return_annotation=UNKNOWN_TYPE,
+                doc="Error while extracting signature: " + str(e),
+            )
+
+    def __hash__(self) -> int:
+        return hash(self.__repr__())
+
+
+@dataclass
+class TypeInfo:
+    doc: str | None
+    fields: dict[str, Any] = field(default_factory=dict)
+    functions: dict[str, FunctionInfo] = field(default_factory=dict)
+
+    def get_member(self, field_name: str) -> Any | FunctionInfo:
+        return self.fields.get(field_name) or self.functions.get(field_name)
+
+    def add_member(
+        self,
+        field_annotations: dict[str, Any],
+        field_name: str,
+        field_value: Any,
+        skip_fields=False,
+    ):
+        if (
+            inspect.isfunction(field_value)
+            or inspect.ismethod(field_value)
+            or inspect.ismethoddescriptor(field_value)
+            or inspect.isbuiltin(field_value)
+        ):
+            self.functions[field_name] = FunctionInfo.extract(field_value)
+
+        elif skip_fields:
+            return
+        elif field_name in field_annotations:
+            self.fields[field_name] = field_annotations[field_name]
+        elif _ := get_origin(field_value):
+            self.fields[field_name] = field_value
+        else:
+            self.fields[field_name] = type(field_value)
+
+    def __hash__(self) -> int:
+        return hash(self.__repr__())
+
+
+def get_type_info(_type: type) -> TypeInfo:
+
+    if _type in TYPE_TO_INFO:
+        return TYPE_TO_INFO[type]
+
+    info = TypeInfo(_type.__doc__)
+
+    # logging.debug("\n\n")
+    # logging.debug("-" * 50)
+    # logging.debug("Indexing type " + _type.__name__)
+
+    field_annotations = (
+        inspect.get_annotations(_type)
+        if inspect.isclass(_type) or callable(_type) or inspect.ismodule(_type)
+        else {}
+    )
+
+    if is_dataclass(_type):
+        handled_fields = set()
+        for field in fields(_type):
+            info.add_member({}, field.name, field.type)
+            handled_fields.add(field.name)
+        for field_name, field_value in inspect.getmembers(_type):
+            if field_name in handled_fields:
+                continue
+
+            # field_value = getattr(_type, field_name)
+            info.add_member(field_annotations, field_name, field_value)
+    else:
+        for field_name, field_value in inspect.getmembers(_type):
+            # field_value = getattr(_type, field_name)
+            # logging.debug(f"{field_name}, {field_value}")
+            info.add_member(field_annotations, field_name, field_value)
+
+    # logging.debug("-" * 50)
+    # logging.debug("\n\n")
+    # logging.debug(info)
+    return info
+
+
+def get_name_of_type(annotation):
+    if annotation is inspect.Parameter.empty:
+        return None
+
+    if annotation is types.NoneType:
+        return "None"
+
+    if annotation is UNKNOWN_TYPE:
+        return "???"
+
+    origin = typing.get_origin(annotation)
+    args = list(map(str, map(get_name_of_type, typing.get_args(annotation))))
+
+    if origin is typing.Union or origin is types.UnionType:
+        return " | ".join(args)
+    elif origin:
+        return f"{origin.__name__}[{', '.join(args)}]"
+
+    try:
+        return annotation.__repr__()
+    except:
+        return annotation.__name__ if hasattr(annotation, "__name__") else annotation
+
+
+def format_function_hints(
+    name: str,
+    signature: FunctionInfo,
+    keyword: str = "def",
+    show_return_type: bool = True,
+):
+    hint = f"{keyword} {name}("
+
+    return_type = signature.return_annotation
+
+    parameters = []
+
+    for name, parameter in signature.parameters:
+        annotation = get_name_of_type(parameter.annotation)
+
+        if annotation is None and parameter.default is not inspect.Parameter.empty:
+            annotation = get_name_of_type(type(parameter.default))
+
+        annotation_string = ": " + str(annotation) if annotation else ""
+        default_string = (
+            " = " + parameter.default.__repr__()  # type: ignore
+            if parameter.default is not inspect.Parameter.empty
+            else ""
+        )
+
+        parameters.append(f"\n\t{name}{annotation_string}{default_string}")
+
+    hint += ",".join(parameters)
+
+    hint += f"\n)"
+
+    if show_return_type and signature.return_annotation is not types.NoneType:
+        hint += f" -> {get_name_of_type(return_type)}"
+
+    return hint
+
+
+def get_doc_string(doc: Any):
+    return "\n---\n" + doc if isinstance(doc, str) else ""
+
+
+def get_variable_description(name: str, value: Any):
+    if inspect.isclass(value):
+        return f"```python\n(variable) {name}: {get_name_of_type(value)}\n```"
+
+    doc_string = get_doc_string(value.__doc__)
+    return f"```python\n(variable) {name}: {get_name_of_type(type(value))}\n```{doc_string}"
+
+
+def get_class_description(name: str, value: type | TypeInfo):
+    if not isinstance(value, TypeInfo):
+        value = get_type_info(value)
+
+    doc_string = get_doc_string(value.doc)
+
+    if not (init := value.functions.get("__init__")):
+        return f"```python\nclass {name}()\n```{doc_string}"
+
+    init = copy(init)
+
+    if len(init.parameters) > 0:
+        init.parameters.pop(0)
+
+    return f"```python\n{format_function_hints(name, init, keyword='class', show_return_type=False)}\n```{doc_string}"
+
+
+def get_function_description(name: str, function: Any):
+    function_info = None
+    if isinstance(function, FunctionInfo):
+        function_info = function
+    else:
+        function_info = FunctionInfo.extract(function)
+
+    doc_string = get_doc_string(function_info.doc)
+
+    return f"```py\n{format_function_hints(name, function_info)}\n```{doc_string}"
+
+
+def get_annotation_description(name: str, type_annotation: Any):
+    if get_origin(type_annotation) is type:
+        args = get_args(type_annotation)
+        description = get_class_description(name, args[0])
+    elif isinstance(type_annotation, TypeInfo):
+        description = get_class_description(name, type_annotation)
+    elif (
+        inspect.isfunction(type_annotation)
+        or inspect.isbuiltin(type_annotation)
+        or isinstance(type_annotation, FunctionInfo)
+    ):
+        description = get_function_description(name, type_annotation)
+    else:
+        description = get_variable_description(name, type_annotation)
+
+    return description

aegis_core-1.5.2/aegis_core/registry.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass, field
+
+from beet import Context
+
+
+@dataclass
+class AegisGameRegistries:
+    ctx: Context
+
+    registries: dict[str, list[str]] = field(init=False, default_factory=dict)
+
+    def __getitem__(self, registry: str) -> list[str]:
+        return self.registries.get(registry) or []
+
+    def __contains__(self, registry: str) -> bool:
+        return registry in self.registries

aegis_core-1.5.2/aegis_core/semantics.py

@@ -0,0 +1,38 @@
+from typing import Literal, Union
+
+TokenModifier = Union[
+    Literal["declaration"],
+    Literal["definition"],
+    Literal["readonly"],
+    Literal["static"],
+    Literal["deprecated"],
+    Literal["abstract"],
+    Literal["async"],
+    Literal["modification"],
+    Literal["documentation"],
+    Literal["defaultLibrary"],
+]
+
+TokenType = Union[
+    Literal["comment"],
+    Literal["string"],
+    Literal["keyword"],
+    Literal["number"],
+    Literal["regexp"],
+    Literal["operator"],
+    Literal["namespace"],
+    Literal["type"],
+    Literal["struct"],
+    Literal["class"],
+    Literal["interface"],
+    Literal["enum"],
+    Literal["typeParameter"],
+    Literal["function"],
+    Literal["method"],
+    Literal["decorator"],
+    Literal["macro"],
+    Literal["variable"],
+    Literal["parameter"],
+    Literal["property"],
+    Literal["label"],
+]

aegis_core-1.5.2/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "aegis_core"
+version = "1.5.2"
+description = "A library to manipulate Mecha for language server usage"
+authors = ["TheNuclearNexus <39636175+TheNuclearNexus@users.noreply.github.com>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+mecha = "^0.96.0"
+bolt = "^0.49.1"
+lsprotocol = "^2023.0.1"
+
+[tool.poetry.group.dev.dependencies]
+isort = "^6.0.0"
+black = "^25.1.0"
+pytest = "^8.1.1"
+
+[tool.isort]
+profile = "black"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"