nova-pl 1.0.0__py3-none-any.whl

nova/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("nova-lang")
+except PackageNotFoundError:
+    __version__ = "1.0.0"

nova/api.py

@@ -0,0 +1,41 @@
+from nova.modules.resolver import ModuleResolver
+from nova.pipeline import create_interpreter
+
+
+def run_source(
+    source: str,
+    input_provider=None,
+    project_root=None,
+    output_callback=None,
+):
+    resolver = ModuleResolver(
+        project_root=project_root,
+    )
+
+    interpreter = create_interpreter(
+        source,
+        input_provider=input_provider,
+        resolver=resolver,
+        output_callback=output_callback,
+    )
+
+    return interpreter.output
+
+
+def run_file(
+    path: str,
+    input_provider=None,
+    project_root=None,
+    output_callback=None,
+):
+    with open(path, "r", encoding="utf-8") as file:
+        source = file.read()
+
+    output = run_source(
+        source,
+        input_provider=input_provider,
+        project_root=project_root,
+        output_callback=output_callback,
+    )
+
+    return source, output

nova/ast/__init__.py

@@ -0,0 +1,101 @@
+from .base import (
+    Node,
+    Statement,
+    Expression,
+)
+
+from .statements import (
+    Program,
+    VariableDeclaration,
+    ConstantDeclaration,
+    FunctionDeclaration,
+    Parameter,
+    Assignment,
+    ArrayAssignment,
+    SchemaDeclaration,
+    PropertyAssignment,
+    ReturnStatement,
+    PrintStatement,
+    BlockStatement,
+    IfStatement,
+    WhileStatement,
+    ForRangeStatement,
+    ForEachStatement,
+    BreakStatement,
+    ContinueStatement,
+    ImportStatement,
+    ImportItem,
+)
+
+from .expressions import (
+    Identifier,
+    ArrayAccess,
+    PropertyAccess,
+    BinaryExpression,
+    UnaryExpression,
+    TernaryExpression,
+    FunctionCall,
+)
+
+from .literals import (
+    NumberLiteral,
+    StringLiteral,
+    BooleanLiteral,
+    NullLiteral,
+    ArrayLiteral,
+    MapEntry,
+    MapLiteral,
+)
+
+from .types import (
+    ArrayType,
+    SchemaField,
+    SchemaType,
+)
+
+__all__ = [
+    "Node",
+    "Statement",
+    "Expression",
+    # Statements
+    "Program",
+    "VariableDeclaration",
+    "ConstantDeclaration",
+    "FunctionDeclaration",
+    "Parameter",
+    "Assignment",
+    "ArrayAssignment",
+    "SchemaDeclaration",
+    "PropertyAssignment",
+    "ReturnStatement",
+    "PrintStatement",
+    "BlockStatement",
+    "IfStatement",
+    "WhileStatement",
+    "ForRangeStatement",
+    "ForEachStatement",
+    "BreakStatement",
+    "ContinueStatement",
+    "ImportStatement",
+    "ImportItem",
+    # Expressions
+    "Identifier",
+    "ArrayAccess",
+    "PropertyAccess",
+    "BinaryExpression",
+    "UnaryExpression",
+    "TernaryExpression",
+    "FunctionCall",
+    # Literals
+    "NumberLiteral",
+    "StringLiteral",
+    "BooleanLiteral",
+    "NullLiteral",
+    "ArrayLiteral",
+    "MapEntry",
+    "MapLiteral",
+    # Types
+    "ArrayType",
+    "SchemaField",
+    "SchemaType",
+]

nova/ast/base.py

@@ -0,0 +1,26 @@
+class Node:
+    def __init__(
+        self,
+        line=None,
+        column=None,
+    ):
+        self.line = line
+        self.column = column
+
+
+class Statement(Node):
+    def __init__(
+        self,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+
+class Expression(Node):
+    def __init__(
+        self,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)

nova/ast/expressions.py

@@ -0,0 +1,148 @@
+from nova.ast.base import Expression
+
+
+class Identifier(Expression):
+    def __init__(
+        self,
+        name,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.name = name
+
+    def __repr__(self):
+        return f"Identifier({self.name!r})"
+
+
+class ArrayAccess(Expression):
+    def __init__(
+        self,
+        array,
+        index,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.array = array
+        self.index = index
+
+    def __repr__(self):
+        return f"ArrayAccess(" f"array={self.array}, " f"index={self.index}" f")"
+
+
+class PropertyAccess(Expression):
+    def __init__(
+        self,
+        target,
+        property_name,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.target = target
+        self.property_name = property_name
+
+    def __repr__(self):
+        return (
+            f"PropertyAccess("
+            f"target={self.target}, "
+            f"property_name={self.property_name!r}"
+            f")"
+        )
+
+
+class BinaryExpression(Expression):
+    def __init__(
+        self,
+        left,
+        operator,
+        right,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.left = left
+        self.operator = operator
+        self.right = right
+
+    def __repr__(self):
+        return (
+            f"BinaryExpression("
+            f"left={self.left}, "
+            f"operator={self.operator!r}, "
+            f"right={self.right}"
+            f")"
+        )
+
+
+class UnaryExpression(Expression):
+    def __init__(
+        self,
+        operator,
+        operand,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.operator = operator
+        self.operand = operand
+
+    def __repr__(self):
+        return (
+            f"UnaryExpression("
+            f"operator={self.operator!r}, "
+            f"operand={self.operand}"
+            f")"
+        )
+
+
+class TernaryExpression(Expression):
+    def __init__(
+        self,
+        condition,
+        true_expression,
+        false_expression,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.condition = condition
+        self.true_expression = true_expression
+        self.false_expression = false_expression
+
+    def __repr__(self):
+        return (
+            f"TernaryExpression("
+            f"condition={self.condition}, "
+            f"true_expression={self.true_expression}, "
+            f"false_expression={self.false_expression}"
+            f")"
+        )
+
+class FunctionCall(Expression):
+    def __init__(
+        self,
+        callee,
+        arguments,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.callee = callee
+        self.arguments = arguments
+
+    def __repr__(self):
+        return (
+            f"FunctionCall("
+            f"callee={self.callee}, "
+            f"arguments={self.arguments}"
+            f")"
+        )

nova/ast/literals.py

@@ -0,0 +1,106 @@
+from nova.ast.base import Expression
+from nova.ast.base import Node
+
+
+class NumberLiteral(Expression):
+    def __init__(
+        self,
+        value,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.value = value
+
+    def __repr__(self):
+        return f"NumberLiteral({self.value})"
+
+
+class StringLiteral(Expression):
+    def __init__(
+        self,
+        value,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.value = value
+
+    def __repr__(self):
+        return f"StringLiteral({self.value!r})"
+
+
+class BooleanLiteral(Expression):
+    def __init__(
+        self,
+        value,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.value = value
+
+    def __repr__(self):
+        return f"BooleanLiteral({self.value})"
+
+
+class NullLiteral(Expression):
+    def __init__(
+        self,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+    def __repr__(self):
+        return "NullLiteral()"
+
+
+class ArrayLiteral(Expression):
+    def __init__(
+        self,
+        elements,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.elements = elements
+
+    def __repr__(self):
+        return f"ArrayLiteral({self.elements})"
+
+
+class MapEntry(Node):
+    def __init__(
+        self,
+        key,
+        value,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.key = key
+        self.value = value
+
+    def __repr__(self):
+        return f"MapEntry(" f"key={self.key!r}, " f"value={self.value}" f")"
+
+
+class MapLiteral(Expression):
+    def __init__(
+        self,
+        entries,
+        line=None,
+        column=None,
+    ):
+        super().__init__(line, column)
+
+        self.entries = entries
+
+    def __repr__(self):
+        return f"MapLiteral({self.entries})"