dalang 0.1.0__py3-none-any.whl

dalang/__init__.py

@@ -0,0 +1,6 @@
+"""Dalang (Data Analytics LANGuage).
+
+Versi 0.1.0 berisi lexer, parser, checker, penerjemah ke Python + DuckDB, serta perintah ``dal check``, ``dal parse``, dan ``dal run``.
+"""
+
+__version__ = "0.1.0"

dalang/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

dalang/ast_nodes.py

@@ -0,0 +1,565 @@
+"""Node AST Dalang (Tata Bahasa v0.1).
+
+Setiap node menyimpan posisi awal (line, col) di sumber, untuk pesan error dan source map.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields, is_dataclass
+from typing import Optional, Union
+
+
+@dataclass
+class Node:
+    line: int = field(default=0, compare=False, repr=False, kw_only=True)
+    col: int = field(default=0, compare=False, repr=False, kw_only=True)
+
+
+# =====================================================================
+# Ekspresi
+# =====================================================================
+
+@dataclass
+class Number(Node):
+    value: str
+
+
+@dataclass
+class String(Node):
+    value: str
+
+
+@dataclass
+class Bool(Node):
+    value: bool
+
+
+@dataclass
+class Missing(Node):
+    pass
+
+
+@dataclass
+class Name(Node):
+    name: str
+
+
+@dataclass
+class ListLit(Node):
+    items: list["Expr"]
+
+
+@dataclass
+class Member(Node):
+    obj: "Expr"
+    name: str
+    quoted: bool = False          # sales."Nilai Penjualan"
+
+
+@dataclass
+class Arg(Node):
+    name: Optional[str]           # argumen bernama: nama: nilai
+    value: "Expr"
+
+
+@dataclass
+class Call(Node):
+    func: "Expr"
+    args: list[Arg]
+
+
+@dataclass
+class Unary(Node):
+    op: str                       # "-" atau "NOT"
+    operand: "Expr"
+
+
+@dataclass
+class Binary(Node):
+    op: str                       # + - * / ^ & MOD AND OR = <> < > <= >= IN
+    left: "Expr"
+    right: "Expr"
+
+
+@dataclass
+class IsMissing(Node):
+    operand: "Expr"
+    negated: bool = False
+
+
+# ---- pengubah pendek (aturan A2) ----
+
+@dataclass
+class Previous(Node):
+    expr: "Expr"
+    unit: str
+
+
+@dataclass
+class LastN(Node):
+    expr: "Expr"
+    count: str
+    unit: str
+
+
+@dataclass
+class ToDate(Node):
+    expr: "Expr"
+    unit: str
+
+
+@dataclass
+class IgnoreFilter(Node):
+    expr: "Expr"
+    target: "Expr"
+
+
+@dataclass
+class ShareOf(Node):
+    expr: "Expr"
+    target: "Expr"
+
+
+@dataclass
+class ForEachRow(Node):
+    expr: "Expr"
+    table: str
+
+
+# ---- klausa panjang / pipeline (aturan A3) ----
+
+@dataclass
+class Coord(Node):
+    target: "Expr"                # name_ref atau satuan waktu (Name)
+    value: "Expr"
+
+
+@dataclass
+class Where(Node):
+    expr: Optional["Expr"]        # None bila klausa milik perintah
+    cond: "Expr"
+
+
+@dataclass
+class At(Node):
+    expr: Optional["Expr"]
+    coords: list[Coord]
+
+
+@dataclass
+class Select(Node):
+    expr: Optional["Expr"]
+    columns: list[str]
+
+
+@dataclass
+class SortBy(Node):
+    expr: Optional["Expr"]
+    key: "Expr"
+    descending: bool = False
+
+
+# ---- bentuk khusus ----
+
+@dataclass
+class Option(Node):
+    name: str
+    value: "Expr"
+
+
+@dataclass
+class Load(Node):
+    format: str
+    path: str
+    options: list[Option]
+
+
+@dataclass
+class Top(Node):
+    count: str
+    table: str
+    key: "Expr"
+
+
+@dataclass
+class Rank(Node):
+    table: str
+    key: "Expr"
+
+
+@dataclass
+class Join(Node):
+    left: str
+    right: str
+    on: "Expr"
+
+
+@dataclass
+class Forecast(Node):
+    measure: str
+    by_unit: str
+    count: str
+    unit: str
+    engine: Optional[str]
+    options: list[Option]
+
+
+@dataclass
+class Regress(Node):
+    target: "Expr"
+    predictors: list["Expr"]
+    engine: Optional[str]
+    options: list[Option]
+
+
+Expr = Union[
+    Number, String, Bool, Missing, Name, ListLit, Member, Call, Unary, Binary, IsMissing,
+    Previous, LastN, ToDate, IgnoreFilter, ShareOf, ForEachRow, Where, At, Select, SortBy,
+    Load, Top, Rank, Join, Forecast, Regress,
+]
+
+
+# =====================================================================
+# Pernyataan
+# =====================================================================
+
+@dataclass
+class Target(Node):
+    name: str
+    column: Optional[str] = None
+
+
+@dataclass
+class Use(Node):
+    language: Optional[str]       # "PYTHON", "R", atau None untuk modul .dal
+    path: str
+    alias: str
+
+
+@dataclass
+class Parameter(Node):
+    name: str
+    type: Optional[str]
+    default: Expr
+    options: list[Option]
+
+
+@dataclass
+class Let(Node):
+    target: Target
+    type: Optional[str]
+    value: Expr
+
+
+@dataclass
+class Set(Node):
+    target: Target
+    value: Expr
+
+
+@dataclass
+class IfBranch(Node):
+    cond: Expr
+    body: list["Stmt"]
+
+
+@dataclass
+class If(Node):
+    branches: list[IfBranch]
+    else_body: Optional[list["Stmt"]]
+    inline: bool = False
+
+
+@dataclass
+class For(Node):
+    var: str
+    start: Expr
+    end: Expr
+    step: Optional[Expr]
+    body: list["Stmt"]
+
+
+@dataclass
+class ForEach(Node):
+    var: str
+    iterable: Expr
+    body: list["Stmt"]
+
+
+@dataclass
+class While(Node):
+    cond: Expr
+    body: list["Stmt"]
+
+
+@dataclass
+class Exit(Node):
+    pass
+
+
+@dataclass
+class Continue(Node):
+    pass
+
+
+@dataclass
+class Param(Node):
+    name: str
+    type: Optional[str]
+    default: Optional[Expr]
+
+
+@dataclass
+class Function(Node):
+    name: str
+    params: list[Param]
+    body: list["Stmt"]
+
+
+@dataclass
+class Return(Node):
+    value: Expr
+
+
+@dataclass
+class Try(Node):
+    body: list["Stmt"]
+    error_name: str
+    handler: list["Stmt"]
+
+
+@dataclass
+class Fail(Node):
+    message: Expr
+
+
+@dataclass
+class Tables(Node):
+    names: list[str]
+
+
+@dataclass
+class Relate(Node):
+    many: Expr
+    one: Expr
+
+
+@dataclass
+class Calendar(Node):
+    column: Expr
+
+
+@dataclass
+class Measure(Node):
+    name: str
+    expr: Expr
+
+
+@dataclass
+class Model(Node):
+    name: str
+    items: list[Union[Tables, Relate, Calendar, Measure]]
+
+
+@dataclass
+class Test(Node):
+    name: str
+    expects: list[Expr]
+
+
+@dataclass
+class Show(Node):
+    values: list[Expr]
+    by: list[Expr]
+    clauses: list[Union[Where, At, Select, SortBy]]
+    options: list[Option]
+
+
+@dataclass
+class Plot(Node):
+    chart: Optional[str]
+    values: list[Expr]
+    by: list[Expr]
+    clauses: list[Union[Where, At, Select, SortBy]]
+    options: list[Option]
+
+
+@dataclass
+class Save(Node):
+    value: Expr
+    format: str
+    path: str
+    options: list[Option]
+
+
+@dataclass
+class Explain(Node):
+    expr: Expr
+    coords: list[Coord]
+    options: list[Option]
+
+
+@dataclass
+class Export(Node):
+    values: list[Expr]
+    by: list[Expr]
+    engine: str
+    options: list[Option]
+
+
+@dataclass
+class Ask(Node):
+    prompt: str
+
+
+@dataclass
+class Append(Node):
+    value: Expr
+    target: str
+
+
+@dataclass
+class Rename(Node):
+    column: Expr
+    new_name: str
+
+
+@dataclass
+class Remove(Node):
+    column: Expr
+
+
+@dataclass
+class Fill(Node):
+    column: Expr
+    value: Expr
+
+
+@dataclass
+class ExprStmt(Node):
+    expr: Expr
+
+
+Stmt = Union[
+    Use, Parameter, Let, Set, If, For, ForEach, While, Exit, Continue, Function, Return,
+    Try, Fail, Model, Test, Show, Plot, Save, Explain, Export, Ask, Append, Rename, Remove,
+    Fill, ExprStmt,
+]
+
+
+@dataclass
+class Program(Node):
+    body: list[Stmt]
+
+
+# =====================================================================
+# Penulisan ulang ekspresi dengan kurung lengkap (untuk tes dan `dal parse`)
+# =====================================================================
+
+def fmt(e: object) -> str:
+    """Tulis ekspresi dengan kurung lengkap, sehingga cara baca parser terlihat."""
+    if isinstance(e, Number):
+        return e.value
+    if isinstance(e, String):
+        return '"' + e.value.replace('"', '""') + '"'
+    if isinstance(e, Bool):
+        return "TRUE" if e.value else "FALSE"
+    if isinstance(e, Missing):
+        return "MISSING"
+    if isinstance(e, Name):
+        return e.name
+    if isinstance(e, ListLit):
+        return "[" + ", ".join(fmt(i) for i in e.items) + "]"
+    if isinstance(e, Member):
+        name = f'"{e.name}"' if e.quoted else e.name
+        return f"{fmt(e.obj)}.{name}"
+    if isinstance(e, Call):
+        args = ", ".join((f"{a.name}: " if a.name else "") + fmt(a.value) for a in e.args)
+        return f"{fmt(e.func)}({args})"
+    if isinstance(e, Unary):
+        sep = " " if e.op == "NOT" else ""
+        return f"({e.op}{sep}{fmt(e.operand)})"
+    if isinstance(e, Binary):
+        return f"({fmt(e.left)} {e.op} {fmt(e.right)})"
+    if isinstance(e, IsMissing):
+        return f"({fmt(e.operand)} IS {'NOT ' if e.negated else ''}MISSING)"
+    if isinstance(e, Previous):
+        return f"({fmt(e.expr)} PREVIOUS {e.unit})"
+    if isinstance(e, LastN):
+        return f"({fmt(e.expr)} LAST {e.count} {e.unit})"
+    if isinstance(e, ToDate):
+        return f"({fmt(e.expr)} {e.unit} TO DATE)"
+    if isinstance(e, IgnoreFilter):
+        return f"({fmt(e.expr)} IGNORE FILTER {fmt(e.target)})"
+    if isinstance(e, ShareOf):
+        return f"({fmt(e.expr)} AS SHARE OF {fmt(e.target)})"
+    if isinstance(e, ForEachRow):
+        return f"({fmt(e.expr)} FOR EACH ROW OF {e.table})"
+    if isinstance(e, Where):
+        return f"({fmt(e.expr)} WHERE {fmt(e.cond)})" if e.expr else f"WHERE {fmt(e.cond)}"
+    if isinstance(e, At):
+        coords = ", ".join(f"{fmt(c.target)} = {fmt(c.value)}" for c in e.coords)
+        return f"({fmt(e.expr)} AT {coords})" if e.expr else f"AT {coords}"
+    if isinstance(e, Select):
+        cols = ", ".join(e.columns)
+        return f"({fmt(e.expr)} SELECT {cols})" if e.expr else f"SELECT {cols}"
+    if isinstance(e, SortBy):
+        tail = f"SORT BY {fmt(e.key)}" + (" DESCENDING" if e.descending else "")
+        return f"({fmt(e.expr)} {tail})" if e.expr else tail
+    if isinstance(e, Load):
+        return f'LOAD {e.format} "{e.path}"' + _fmt_opts(e.options)
+    if isinstance(e, Top):
+        return f"(TOP {e.count} {e.table} BY {fmt(e.key)})"
+    if isinstance(e, Rank):
+        return f"(RANK {e.table} BY {fmt(e.key)})"
+    if isinstance(e, Join):
+        return f"(JOIN {e.left}, {e.right} ON {fmt(e.on)})"
+    if isinstance(e, Forecast):
+        engine = f" USING {e.engine}" if e.engine else ""
+        return (f"(FORECAST {e.measure} BY {e.by_unit} NEXT {e.count} {e.unit}{engine}"
+                + _fmt_opts(e.options) + ")")
+    if isinstance(e, Regress):
+        engine = f" USING {e.engine}" if e.engine else ""
+        preds = ", ".join(fmt(p) for p in e.predictors)
+        return f"(REGRESS {fmt(e.target)} ON {preds}{engine}" + _fmt_opts(e.options) + ")"
+    if isinstance(e, Coord):
+        return f"{fmt(e.target)} = {fmt(e.value)}"
+    return f"<{type(e).__name__}>"
+
+
+def _fmt_opts(options: list[Option]) -> str:
+    if not options:
+        return ""
+    return " WITH " + ", ".join(f"{o.name}: {fmt(o.value)}" for o in options)
+
+
+def dump(node: object, indent: int = 0) -> str:
+    """Tampilan pohon AST yang ringkas, satu node per baris."""
+    pad = "  " * indent
+    if isinstance(node, list):
+        return "\n".join(dump(n, indent) for n in node)
+    if not is_dataclass(node):
+        return f"{pad}{node!r}"
+    expr_types = Expr.__args__  # type: ignore[attr-defined]
+    if isinstance(node, expr_types):
+        return f"{pad}{fmt(node)}"
+    lines = [f"{pad}{type(node).__name__}  (baris {node.line})"]
+    for f in fields(node):
+        if f.name in ("line", "col"):
+            continue
+        value = getattr(node, f.name)
+        if value is None or value == [] or value is False:
+            continue
+        if isinstance(value, list):
+            lines.append(f"{pad}  {f.name}:")
+            for item in value:
+                lines.append(dump(item, indent + 2))
+        elif is_dataclass(value):
+            if isinstance(value, expr_types):
+                lines.append(f"{pad}  {f.name}: {fmt(value)}")
+            else:
+                lines.append(f"{pad}  {f.name}:")
+                lines.append(dump(value, indent + 2))
+        else:
+            lines.append(f"{pad}  {f.name}: {value!r}")
+    return "\n".join(lines)