saslite 0.1.0__py3-none-any.whl

saslite/__init__.py

@@ -0,0 +1,7 @@
+"""SASLite - Lightweight local SAS language interpreter."""
+
+__version__ = "0.1.0"
+
+from saslite.api.facade import SasInterpreter
+
+__all__ = ["SasInterpreter"]

saslite/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m saslite"""
+
+from saslite.cli.main import main
+
+raise SystemExit(main())

saslite/api/facade.py

@@ -0,0 +1,208 @@
+"""SasInterpreter — the main programming API for SASLite."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+from saslite.macro.expander import MacroExpander
+from saslite.parser.program_parser import ProgramParser
+from saslite.session.session import Session
+from saslite.storage.path_resolver import StorageRouter
+from saslite.executor.dispatcher import Dispatcher
+from saslite.executor.proc.registry import (
+    handle_proc_print, handle_proc_sort, handle_proc_contents,
+    handle_proc_means, handle_proc_freq, handle_proc_import, handle_proc_export,
+    handle_proc_append, handle_proc_datasets,
+)
+from saslite.runtime.execution_result import RunSummary
+from saslite.diagnostics.reporter import Reporter
+
+
+class SasInterpreter:
+    """Main API for executing SAS code."""
+
+    def __init__(self, work_dir: str | None = None) -> None:
+        self._macro = MacroExpander()
+        self._parser = ProgramParser()
+        self._session = Session(StorageRouter(work_dir))
+        self._reporter = Reporter()
+
+    @property
+    def session(self) -> Session:
+        return self._session
+
+    @property
+    def reporter(self) -> Reporter:
+        return self._reporter
+
+    def execute(self, source: str, source_name: str = "<input>") -> RunSummary:
+        """Execute SAS source code."""
+        try:
+            # Step 0: Preprocess DATALINES blocks
+            source, datalines_list = self._preprocess_datalines(source)
+
+            # Step 1: Macro expansion
+            expanded = self._macro.expand(source)
+
+            # Report %PUT output
+            for line in self._macro.put_output:
+                self._reporter.log(line)
+            self._macro.put_output.clear()
+
+            if not expanded.strip():
+                return RunSummary(success=True)
+
+            # Step 2: Parse
+            program = self._parser.parse(expanded)
+
+            # Step 2.5: Inject DATALINES data into InputNodes
+            self._inject_datalines(program, datalines_list)
+
+            # Step 3: Dispatch and execute
+            dispatcher = Dispatcher(self._session, self._reporter)
+
+            # Register PROC handlers
+            session = self._session
+            reporter = self._reporter
+            dispatcher.register_proc("PRINT", lambda p: handle_proc_print(p, session, reporter))
+            dispatcher.register_proc("SORT", lambda p: handle_proc_sort(p, session, reporter))
+            dispatcher.register_proc("CONTENTS", lambda p: handle_proc_contents(p, session, reporter))
+            dispatcher.register_proc("MEANS", lambda p: handle_proc_means(p, session, reporter))
+            dispatcher.register_proc("SUMMARY", lambda p: handle_proc_means(p, session, reporter))
+            dispatcher.register_proc("FREQ", lambda p: handle_proc_freq(p, session, reporter))
+            dispatcher.register_proc("IMPORT", lambda p: handle_proc_import(p, session, reporter))
+            dispatcher.register_proc("EXPORT", lambda p: handle_proc_export(p, session, reporter))
+            dispatcher.register_proc("APPEND", lambda p: handle_proc_append(p, session, reporter))
+            dispatcher.register_proc("DATASETS", lambda p: handle_proc_datasets(p, session, reporter))
+
+            return dispatcher.run(program)
+
+        except Exception as e:
+            summary = RunSummary(success=False, error=str(e))
+            self._reporter.error(str(e))
+            return summary
+
+    def execute_file(
+        self,
+        path: str | Path,
+        encoding: str = "utf-8",
+        errors: str = "strict",
+    ) -> RunSummary:
+        """Execute a SAS script file."""
+        path = Path(path)
+        source = path.read_text(encoding=encoding, errors=errors)
+        return self.execute(source, source_name=str(path))
+
+    def create_dataset(self, name: str, df: pd.DataFrame, libref: str = "WORK") -> None:
+        """Create a dataset from a pandas DataFrame."""
+        from saslite.runtime.dataset import Dataset
+        ds = Dataset.from_dataframe(df, name=name, libref=libref)
+        self._session.put_dataset(libref, name, ds)
+
+    def get_dataset(self, libref: str, name: str) -> pd.DataFrame:
+        """Get a dataset as a pandas DataFrame."""
+        ds = self._session.get_dataset(libref, name)
+        return ds.data
+
+    def import_csv(self, filepath: str, dataset_name: str, libref: str = "WORK") -> None:
+        """Import a CSV file as a dataset."""
+        df = pd.read_csv(filepath)
+        self.create_dataset(dataset_name, df, libref)
+
+    def export_csv(self, dataset_name: str, filepath: str, libref: str = "WORK") -> None:
+        """Export a dataset to CSV."""
+        from saslite.runtime.formatting import csv_dataframe
+
+        ds = self._session.get_dataset(libref, dataset_name)
+        csv_dataframe(ds).to_csv(filepath, index=False)
+
+    @staticmethod
+    def _preprocess_datalines(source: str) -> tuple[str, list[str]]:
+        """Extract DATALINES/CARDS blocks and replace with assignment markers.
+
+        Returns (modified_source, list_of_raw_data_strings).
+        """
+        datalines_list: list[str] = []
+        _EMPTY_PLACEHOLDER = "\x01"  # placeholder for "" and '' empty strings
+
+        def _replace_empty_strings(data: str) -> str:
+            """Replace \"\" and '' with placeholder so they survive escaping."""
+            return data.replace('""', _EMPTY_PLACEHOLDER).replace("''", _EMPTY_PLACEHOLDER)
+
+        # Pass 1: Handle inline DATALINES (same line as keyword)
+        # Pattern: DATALINES; non_semicolon_data ;
+        def _replace_inline(m: re.Match) -> str:
+            data = m.group(1)
+            data = _replace_empty_strings(data)
+            idx = len(datalines_list)
+            datalines_list.append(data)
+            escaped = data.replace("\\", "\\\\").replace('"', '\\"')
+            return f'__DATALINES_{idx}__ = "{escaped}";'
+
+        source = re.sub(
+            r"(?i)(?:DATALINES|CARDS|LINES4)\s*;\s*([^;]+?)\s*;",
+            _replace_inline,
+            source,
+        )
+
+        # Pass 2: Handle multi-line DATALINES (keyword on own line)
+        lines = source.split("\n")
+        result_lines: list[str] = []
+        i = 0
+        while i < len(lines):
+            stripped = lines[i].strip().upper()
+            if stripped in ("DATALINES;", "CARDS;", "LINES4;"):
+                data_lines: list[str] = []
+                i += 1
+                while i < len(lines):
+                    if lines[i].strip() == ";":
+                        break
+                    data_lines.append(lines[i])
+                    i += 1
+                idx = len(datalines_list)
+                datalines_data = "\n".join(data_lines)
+                datalines_data = _replace_empty_strings(datalines_data)
+                datalines_list.append(datalines_data)
+                escaped = datalines_data.replace("\\", "\\\\").replace('"', '\\"')
+                result_lines.append(f'  __DATALINES_{idx}__ = "{escaped}";')
+                i += 1
+            else:
+                result_lines.append(lines[i])
+                i += 1
+
+        return "\n".join(result_lines), datalines_list
+
+    @staticmethod
+    def _inject_datalines(program: Any, datalines_list: list[str]) -> None:
+        """Inject DATALINES data into DataStepNodes that have InputNodes."""
+        from saslite.ast.data_step import DataStepNode, InputNode, AssignNode
+        from saslite.ast.expressions import LiteralNode
+
+        datalines_idx = 0
+        for step in program.steps:
+            if not isinstance(step, DataStepNode):
+                continue
+
+            input_node = None
+            placeholder_idx = None
+
+            for j, stmt in enumerate(step.statements):
+                if isinstance(stmt, InputNode):
+                    input_node = stmt
+                elif (isinstance(stmt, AssignNode)
+                      and stmt.target.startswith("__DATALINES_")
+                      and isinstance(stmt.expr, LiteralNode)
+                      and stmt.expr.literal_type == "string"):
+                    placeholder_idx = j
+
+            if input_node is not None and placeholder_idx is not None:
+                # Extract data from the placeholder assignment
+                placeholder = step.statements[placeholder_idx]
+                raw_data = placeholder.expr.value
+                input_node.datalines_data = raw_data
+                # Remove the placeholder statement
+                step.statements.pop(placeholder_idx)

saslite/api/results.py

@@ -0,0 +1,5 @@
+"""API result types (re-exported from runtime)."""
+
+from saslite.runtime.execution_result import StepResult, RunSummary
+
+__all__ = ["StepResult", "RunSummary"]

saslite/ast/base.py

@@ -0,0 +1,22 @@
+"""Base AST node types."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Span:
+    """Source location information."""
+    start_line: int = 0
+    start_col: int = 0
+    end_line: int = 0
+    end_col: int = 0
+    source: str = ""
+
+
+@dataclass
+class Node:
+    """Base AST node."""
+    span: Span = field(default_factory=Span)

saslite/ast/data_step.py

@@ -0,0 +1,207 @@
+"""DATA step AST nodes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from saslite.ast.base import Node
+
+
+@dataclass
+class DataStepNode(Node):
+    """DATA step."""
+    target: str = ""
+    target_options: dict[str, Any] = field(default_factory=dict)
+    statements: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class SetNode(Node):
+    """SET statement."""
+    datasets: list[Any] = field(default_factory=list)
+    options: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class MergeNode(Node):
+    """MERGE statement."""
+    datasets: list[Any] = field(default_factory=list)
+    by_vars: list[str] = field(default_factory=list)
+
+
+@dataclass
+class DatasetRefNode(Node):
+    """Dataset reference with options."""
+    name: str = ""
+    libref: str = "WORK"
+    options: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class AssignNode(Node):
+    """Variable assignment."""
+    target: str = ""
+    expr: Any = None
+
+
+@dataclass
+class IfNode(Node):
+    """IF/THEN/ELSE statement."""
+    condition: Any = None
+    then_stmt: Any = None
+    else_stmt: Any = None
+
+
+@dataclass
+class IfBlockNode(Node):
+    """IF condition THEN DO; ... END; ELSE DO; ... END;"""
+    condition: Any = None
+    then_body: list[Any] = field(default_factory=list)
+    else_body: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class DoNode(Node):
+    """DO block or iterative DO loop."""
+    body: list[Any] = field(default_factory=list)
+    # Iterative DO
+    var: str = ""
+    start: Any = None
+    end: Any = None
+    by: Any = None
+    # WHILE/UNTIL
+    while_cond: Any = None
+    until_cond: Any = None
+
+
+@dataclass
+class OutputNode(Node):
+    """OUTPUT statement."""
+    target: str = ""
+
+
+@dataclass
+class DeleteNode(Node):
+    """DELETE statement."""
+    pass
+
+
+@dataclass
+class StopNode(Node):
+    """STOP statement."""
+    pass
+
+
+@dataclass
+class RetainNode(Node):
+    """RETAIN statement."""
+    items: list[tuple[str, Any | None]] = field(default_factory=list)
+
+
+@dataclass
+class WhereNode(Node):
+    """WHERE statement."""
+    condition: Any = None
+
+
+@dataclass
+class KeepNode(Node):
+    """KEEP statement (in-step, not option)."""
+    variables: list[str] = field(default_factory=list)
+
+
+@dataclass
+class DropNode(Node):
+    """DROP statement (in-step, not option)."""
+    variables: list[str] = field(default_factory=list)
+
+
+@dataclass
+class RenameNode(Node):
+    """RENAME statement."""
+    mapping: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class ArrayNode(Node):
+    """ARRAY statement."""
+    name: str = ""
+    bounds: Any = None
+    variables: list[str] = field(default_factory=list)
+    is_character: bool = False
+
+
+@dataclass
+class FormatNode(Node):
+    """FORMAT statement."""
+    items: list[tuple[str, str]] = field(default_factory=list)
+
+
+@dataclass
+class LabelNode(Node):
+    """LABEL statement."""
+    items: list[tuple[str, str]] = field(default_factory=list)
+
+
+@dataclass
+class InfileNode(Node):
+    """INFILE statement — specify input source and options."""
+    source: str = ""  # 'datalines', 'cards', or file path
+    options: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class InputNode(Node):
+    """INPUT statement — variable list for reading raw data."""
+    variables: list[str] = field(default_factory=list)
+    is_character: dict[str, bool] = field(default_factory=dict)
+    formats: dict[str, str] = field(default_factory=dict)
+    datalines_data: str = ""
+
+
+@dataclass
+class SubstrAssignNode(Node):
+    """SUBSTR(target, start [, length]) = expression;"""
+    target: str = ""
+    start: Any = None
+    length: Any = None
+    expr: Any = None
+
+
+@dataclass
+class LengthNode(Node):
+    """LENGTH statement — set variable lengths."""
+    items: list[tuple[str, int | None]] = field(default_factory=list)
+
+
+@dataclass
+class AttribNode(Node):
+    """ATTRIB statement — set variable attributes."""
+    items: list[tuple[str, str, str]] = field(default_factory=list)
+
+
+@dataclass
+class PutNode(Node):
+    """PUT statement — write to log."""
+    items: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class PutItemNode(Node):
+    """A single item in a PUT list: variable, literal, or formatting."""
+    expr: Any = None
+    format_spec: str = ""
+
+
+@dataclass
+class UpdateDataNode(Node):
+    """DATA step UPDATE statement (not SQL UPDATE)."""
+    datasets: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class CallSymputNode(Node):
+    """CALL SYMPUT('macro_var', value)."""
+    macro_var: Any = None
+    value: Any = None

saslite/ast/expressions.py

@@ -0,0 +1,105 @@
+"""Expression AST nodes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from saslite.ast.base import Node
+
+
+@dataclass
+class LiteralNode(Node):
+    """Literal value."""
+    value: Any = None
+    literal_type: str = "string"  # string, number, missing
+
+
+@dataclass
+class VariableNode(Node):
+    """Variable reference."""
+    name: str = ""
+
+
+@dataclass
+class BinaryOpNode(Node):
+    """Binary operation."""
+    op: str = ""
+    left: Any = None
+    right: Any = None
+
+
+@dataclass
+class UnaryOpNode(Node):
+    """Unary operation."""
+    op: str = ""
+    operand: Any = None
+
+
+@dataclass
+class FunctionCallNode(Node):
+    """Function call."""
+    name: str = ""
+    args: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class InListNode(Node):
+    """IN (list) expression."""
+    expr: Any = None
+    values: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class BetweenNode(Node):
+    """BETWEEN expression."""
+    expr: Any = None
+    low: Any = None
+    high: Any = None
+
+
+@dataclass
+class CaseNode(Node):
+    """CASE WHEN expression."""
+    conditions: list[Any] = field(default_factory=list)
+    results: list[Any] = field(default_factory=list)
+    else_result: Any = None
+
+
+@dataclass
+class SubqueryNode(Node):
+    """Subquery expression."""
+    select_node: Any = None
+
+
+@dataclass
+class LikeNode(Node):
+    """LIKE expression."""
+    expr: Any = None
+    pattern: Any = None
+    negated: bool = False
+
+
+@dataclass
+class ExistsNode(Node):
+    """EXISTS (subquery) expression."""
+    select_node: Any = None
+
+
+@dataclass
+class CalculatedNode(Node):
+    """CALCULATED column reference in PROC SQL."""
+    name: str = ""
+
+
+@dataclass
+class ScalarSubqueryNode(Node):
+    """Scalar subquery: (SELECT ... ) used as an expression."""
+    select_node: Any = None
+
+
+@dataclass
+class ArrayRefNode(Node):
+    """Array subscript reference: arr[i]."""
+    name: str = ""
+    index: Any = None

saslite/ast/proc.py

@@ -0,0 +1,92 @@
+"""PROC (non-SQL) AST nodes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from saslite.ast.base import Node
+
+
+@dataclass
+class ProcNode(Node):
+    """Generic PROC statement."""
+    proc_name: str = ""
+    options: dict[str, Any] = field(default_factory=dict)
+    statements: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class VarListNode(Node):
+    """VAR statement."""
+    variables: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ByNode(Node):
+    """BY statement."""
+    variables: list[str] = field(default_factory=list)
+    descending: list[bool] = field(default_factory=list)
+
+
+@dataclass
+class IdNode(Node):
+    """ID statement."""
+    variables: list[str] = field(default_factory=list)
+
+
+@dataclass
+class SumNode(Node):
+    """SUM statement (for PROC PRINT)."""
+    variables: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ClassNode(Node):
+    """CLASS statement (for PROC MEANS/FREQ)."""
+    variables: list[str] = field(default_factory=list)
+
+
+@dataclass
+class OutputNode(Node):
+    """OUTPUT OUT= statement (for PROC MEANS/FREQ)."""
+    out: str = ""
+    out_libref: str = "WORK"
+    stats: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class TablesNode(Node):
+    """TABLES statement (for PROC FREQ)."""
+    table_specs: list[str] = field(default_factory=list)
+    options: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class FreqTableSpec(Node):
+    """Single table specification in PROC FREQ TABLES statement.
+    e.g., a * b / norow nocol means: cross-tab of a and b, suppress row/col percents.
+    """
+    var_names: list[str] = field(default_factory=list)
+    options: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ProcImportNode(Node):
+    """PROC IMPORT."""
+    datafile: str = ""
+    out: str = ""
+    out_libref: str = "WORK"
+    dbms: str = "csv"
+    getnames: bool = True
+    delimiter: str = ","
+
+
+@dataclass
+class ProcExportNode(Node):
+    """PROC EXPORT."""
+    data: str = ""
+    data_libref: str = "WORK"
+    outfile: str = ""
+    dbms: str = "csv"
+    delimiter: str = ","

saslite/ast/program.py

@@ -0,0 +1,36 @@
+"""Top-level program AST nodes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from saslite.ast.base import Node
+
+
+@dataclass
+class ProgramNode(Node):
+    """Root node containing all steps."""
+    steps: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class LibnameNode(Node):
+    """LIBNAME statement."""
+    libref: str = ""
+    engine: str = ""
+    path: str = ""
+    options: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class OptionsNode(Node):
+    """OPTIONS statement."""
+    options: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class FilenameNode(Node):
+    """FILENAME statement."""
+    fileref: str = ""
+    filepath: str = ""