astreum 0.2.29__py3-none-any.whl → 0.2.61__py3-none-any.whl

astreum/utils/bytes.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+
+def hex_to_bytes(value: str, *, expected_length: Optional[int] = None) -> bytes:
+    """Convert a 0x-prefixed hex string into raw bytes."""
+    if not isinstance(value, str):
+        raise TypeError("hex value must be provided as a string")
+
+    if not value.startswith(("0x", "0X")):
+        raise ValueError("hex value must start with '0x'")
+
+    hex_digits = value[2:]
+    if len(hex_digits) % 2:
+        raise ValueError("hex value must have an even number of digits")
+
+    try:
+        result = bytes.fromhex(hex_digits)
+    except ValueError as exc:
+        raise ValueError("hex value contains non-hexadecimal characters") from exc
+
+    if expected_length is not None and len(result) != expected_length:
+        raise ValueError(f"hex value must decode to exactly {expected_length} bytes")
+
+    return result

astreum/utils/integer.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Optional, Union
+
+ByteLike = Union[bytes, bytearray, memoryview]
+
+
+def int_to_bytes(value: Optional[int]) -> bytes:
+    """Convert an integer to a little-endian byte string with minimal length."""
+    if value is None:
+        return b""
+    value = int(value)
+    if value == 0:
+        return b"\x00"
+    length = (value.bit_length() + 7) // 8
+    return value.to_bytes(length, "little", signed=False)
+
+
+def bytes_to_int(data: Optional[ByteLike]) -> int:
+    """Convert a little-endian byte string to an integer."""
+    if not data:
+        return 0
+    if isinstance(data, memoryview):
+        data = data.tobytes()
+    return int.from_bytes(bytes(data), "little", signed=False)

astreum/utils/logging.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import atexit
+import inspect
+import gzip
+import json
+import logging
+import logging.handlers
+import os
+import pathlib
+import platform
+import queue
+import shutil
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from blake3 import blake3
+
+# Fixed identity for all loggers in this library
+_ORG_NAME = "Astreum"
+_PRODUCT_NAME = "lib-py"
+
+
+def _safe_path(path_str: str) -> Optional[pathlib.Path]:
+    try:
+        return pathlib.Path(path_str).resolve()
+    except Exception:
+        try:
+            return pathlib.Path(path_str).absolute()
+        except Exception:
+            return None
+
+
+def _hash_path(path: pathlib.Path) -> str:
+    try:
+        data = str(path).encode("utf-8", errors="ignore")
+    except Exception:
+        data = repr(path).encode("utf-8", errors="ignore")
+    return blake3(data).hexdigest()
+
+
+def _find_caller_path() -> pathlib.Path:
+    stack = inspect.stack()
+    candidates: list[pathlib.Path] = []
+    for frame_info in stack[2:]:
+        filename = frame_info.filename
+        if not filename:
+            continue
+        path = _safe_path(filename)
+        if path is None:
+            continue
+        candidates.append(path)
+        if "astreum" not in path.parts:
+            return path
+
+    if candidates:
+        return candidates[0]
+    return pathlib.Path.cwd()
+
+
+def _derive_instance_id() -> str:
+    return _hash_path(_find_caller_path())[:16]
+
+
+def _log_root(org: str, product: str, instance_id: str) -> pathlib.Path:
+    """Resolve the base directory for logs using platform defaults."""
+    if platform.system() == "Windows":
+        base = os.getenv("LOCALAPPDATA") or str(pathlib.Path.home())
+        return pathlib.Path(base) / org / product / "logs" / instance_id
+
+    xdg_state = os.getenv("XDG_STATE_HOME")
+    base_path = pathlib.Path(xdg_state) if xdg_state else pathlib.Path.home() / ".local" / "state"
+    return base_path / org / product / "logs" / instance_id
+
+
+class JSONFormatter(logging.Formatter):
+    """Log record formatter that emits JSON objects per line."""
+
+    def format(self, record: logging.LogRecord) -> str:  # type: ignore[override]
+        payload: Dict[str, Any] = {
+            "ts": datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            "msg": record.getMessage(),
+            "pid": record.process,
+            "thread": record.threadName,
+            "module": record.module,
+            "func": record.funcName,
+            "instance_id": getattr(record, "instance_id", None),
+        }
+
+        for key, value in record.__dict__.items():
+            if key in payload or key.startswith(("_", "msecs", "relativeCreated")):
+                continue
+            try:
+                json.dumps(value)
+            except Exception:
+                continue
+            payload[key] = value
+
+        return json.dumps(payload, ensure_ascii=False)
+
+
+def _gzip_rotator(src: str, dst: str) -> None:
+    """Rotate the log file by gzipping it and removing the original."""
+    with open(src, "rb") as source, gzip.open(f"{dst}.gz", "wb") as target:
+        shutil.copyfileobj(source, target)
+    os.remove(src)
+
+
+def _namer(default_name: str) -> str:
+    """Custom name for rotated logs: node-YYYY-MM-DD.log."""
+    path = pathlib.Path(default_name)
+    parent = path.parent
+    name = path.name
+    fragments = name.split(".log.")
+    if len(fragments) != 2:
+        return default_name
+    stem, date_part = fragments
+    return str(parent / f"{stem}-{date_part}.log")
+
+
+def _human_line(record: logging.LogRecord) -> str:
+    """Format a record as a concise human-readable line."""
+    dt = datetime.fromtimestamp(record.created, tz=timezone.utc)
+    stamp = f"{dt:%Y-%m-%d}-{dt:%S}-{dt:%M}"
+    return f"[{stamp}] [{record.levelname.lower()}] {record.getMessage()}"
+
+
+class HumanFormatter(logging.Formatter):
+    """Simple formatter for optional verbose console output."""
+
+    def format(self, record: logging.LogRecord) -> str:  # type: ignore[override]
+        return _human_line(record)
+
+
+def _shutdown_listener(listener: logging.handlers.QueueListener, handlers: list[logging.Handler]) -> None:
+    """Stop the queue listener and close handlers on interpreter exit."""
+    try:
+        listener.stop()
+    except Exception:
+        pass
+    finally:
+        for handler in handlers:
+            try:
+                handler.close()
+            except Exception:
+                pass
+
+
+def logging_setup(config: dict) -> logging.LoggerAdapter:
+    """Configure logging according to the runtime config and return an adapter."""
+    if config is None:
+        config = {}
+    elif not isinstance(config, dict):
+        config = dict(config)
+
+    org = _ORG_NAME
+    product = _PRODUCT_NAME
+    instance_id = _derive_instance_id()
+
+    retention_value = config.get("retention_days")
+    retention_days = int(retention_value) if retention_value is not None else 90
+
+    verbose = bool(config.get("verbose", False))
+
+    log_dir = _log_root(org, product, instance_id)
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    base_file = log_dir / "node.log"
+    file_handler = logging.handlers.TimedRotatingFileHandler(
+        filename=str(base_file),
+        when="midnight",
+        interval=1,
+        backupCount=max(retention_days, 0),
+        utc=True,
+        encoding="utf-8",
+        delay=True,
+    )
+    file_handler.setFormatter(JSONFormatter())
+    file_handler.rotator = _gzip_rotator
+    file_handler.namer = _namer
+
+    handler_list: list[logging.Handler] = [file_handler]
+
+    if verbose:
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_handler.setFormatter(HumanFormatter())
+        handler_list.append(console_handler)
+
+    log_queue: queue.Queue[logging.LogRecord] = queue.Queue(-1)
+    queue_handler = logging.handlers.QueueHandler(log_queue)
+
+    base_logger = logging.getLogger(f"{product}.{instance_id}")
+    base_logger.setLevel(logging.INFO)
+    base_logger.handlers.clear()
+    base_logger.propagate = False
+    base_logger.addHandler(queue_handler)
+
+    listener = logging.handlers.QueueListener(
+        log_queue, *handler_list, respect_handler_level=True
+    )
+    listener.daemon = True
+    listener.start()
+    atexit.register(_shutdown_listener, listener, handler_list)
+
+    adapter = logging.LoggerAdapter(base_logger, {"instance_id": instance_id})
+    setattr(adapter, "_queue_listener", listener)
+    setattr(adapter, "_handlers", handler_list)
+
+    return adapter
+
+
+__all__ = [
+    "HumanFormatter",
+    "JSONFormatter",
+    "logging_setup",
+]

{astreum-0.2.29.dist-info → astreum-0.2.61.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.29
+Version: 0.2.61
 Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib
@@ -35,6 +35,8 @@ When initializing an `astreum.Node`, pass a dictionary with any of the options b
 | `validation_secret_key`     | hex string | `None`         | X25519 private key that lets the node participate in the validation route. Leave unset for a non‑validator node.                                                                 |
 | `storage_path`              | string     | `None`         | Directory where objects are persisted. If *None*, the node uses an in‑memory store.                                                                                              |
 | `storage_get_relay_timeout` | float      | `5`            | Seconds to wait for an object requested from peers before timing‑out.                                                                                                            |
+| `logging_retention`         | int        | `90`           | Number of days to keep rotated log files (daily gzip).                                                                                                                           |
+| `verbose`                   | bool       | `False`        | When **True**, also mirror JSON logs to stdout with a human-readable format.                                                                                                     |
 
 ### Networking
 
@@ -76,24 +78,45 @@ node = Node(config)
 The Lispeum virtual machine (VM) is embedded inside `astreum.Node`. You feed it Lispeum source text, and the node tokenizes, parses, and **evaluates** the resulting AST inside an isolated environment.
 
 ```python
-from astreum.node import Node
-from astreum.machine.tokenizer import tokenize
-from astreum.machine.parser import parse
+# Define a named function int.add (stack body) and call it with bytes 1 and 2
+
+import uuid
+from astreum import Node, Env, Expr
+
+# 1) Spin‑up a stand‑alone VM
+node = Node()
+
+# 2) Create an environment (simple manual setup)
+env_id = uuid.uuid4()
+node.environments[env_id] = Env()
+
+# 3) Build a function value using a low‑level stack body via `sk`.
+# Body does: $0 $1 add   (i.e., a + b)
+low_body = Expr.ListExpr([
+    Expr.Symbol("$0"),  # a (first arg)
+    Expr.Symbol("$1"),  # b (second arg)
+    Expr.Symbol("add"),
+])
 
-# 1. Spin‑up a stand‑alone VM (machine‑only node).
-node = Node({"machine-only": True})
+fn_body = Expr.ListExpr([
+    Expr.Symbol("a"),
+    Expr.Symbol("b"),
+    Expr.ListExpr([low_body, Expr.Symbol("sk")]),
+])
 
-# 2. Create an environment.
-env_id = node.machine_create_environment()
+params = Expr.ListExpr([Expr.Symbol("a"), Expr.Symbol("b")])
+int_add_fn = Expr.ListExpr([fn_body, params, Expr.Symbol("fn")])
 
-# 3. Convert Lispeum source → Expr AST.
-source = '(+ 1 (* 2 3))'
-expr, _ = parse(tokenize(source))
+# 4) Store under the name "int.add"
+node.env_set(env_id, b"int.add", int_add_fn)
 
-# 4. Evaluate
-result = node.machine_expr_eval(env_id=env_id, expr=expr)  # -> Expr.Integer(7)
+# 5) Retrieve the function and call it with bytes 1 and 2
+bound = node.env_get(env_id, b"int.add")
+call = Expr.ListExpr([Expr.Byte(1), Expr.Byte(2), bound])
+res  = node.high_eval(env_id, call)
 
-print(result.value)  # 7
+# sk returns a list of bytes; for 1+2 expect a single byte with value 3
+print([b.value for b in res.elements])  # [3]
 ```
 
 ### Handling errors
@@ -115,9 +138,22 @@ except ParseError as e:
 
 ---
 
+
+## Logging
+
+Every `Node` instance wires up structured logging automatically:
+
+- Logs land in per-instance files named `node.log` under `%LOCALAPPDATA%\Astreum\lib-py\logs/<instance_id>` on Windows and `$XDG_STATE_HOME` (or `~/.local/state`)/`Astreum/lib-py/logs/<instance_id>` on other platforms. The `<instance_id>` is the first 16 hex characters of a BLAKE3 hash of the caller's file path, so running the node from different entry points keeps their logs isolated.
+- Files rotate at midnight UTC with gzip compression (`node-YYYY-MM-DD.log.gz`) and retain 90 days by default. Override via `config["logging_retention"]`.
+- Each event is a single JSON line containing timestamp, level, logger, message, process/thread info, module/function, and the derived `instance_id`.
+- Set `config["verbose"] = True` to mirror logs to stdout in a human-friendly format like `[2025-04-13-42-59] [info] Starting Astreum Node`.
+- The very first entry emitted is the banner `Starting Astreum Node`, signalling that the logging pipeline is live before other subsystems spin up.
+
 ## Testing
 
 ```bash
+python3 -m venv venv
 source venv/bin/activate
+pip install -e .
 python3 -m unittest discover -s tests
 ```

astreum-0.2.61.dist-info/RECORD

@@ -0,0 +1,57 @@
+astreum/__init__.py,sha256=9tzA27B_eG5wRF1SAWJIV7xTmCcR1QFc123b_cvFOa4,345
+astreum/_node.py,sha256=S-_NsRVuMpcFxxG6ZD_C4sZU9ms6JueD7ZJKHpBSMiw,6997
+astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
+astreum/node.py,sha256=MmlK3jaANTMB3ZAxR8IaSc82OS9meJmVawYIVURADbg,39689
+astreum/_communication/__init__.py,sha256=XJui0yOcfAur4HKt-8sSRlwB-MSU1rchkuOAY-nKDOE,207
+astreum/_communication/message.py,sha256=Wl1IITj7eY9_q0IOT4J7c5gsjS1bF51CH7GcSSuu5OM,3327
+astreum/_communication/peer.py,sha256=CbqkyCwhFCiC2spd1-KjNdeVGNjjt2ECVs8uHot-ETI,875
+astreum/_communication/ping.py,sha256=u_DQTZJsbMdYiDDqjdZDsLaN5na2m9WZjVeEM3zq9_Y,955
+astreum/_communication/route.py,sha256=Dqw8utefBeesZ311Nyizb7PO-g5dl26AoIUavttojHA,4037
+astreum/_communication/setup.py,sha256=EN2GyVfGlVtkSHMhZWwJN33y-Ycfdvq9tjr38Myrmqg,11739
+astreum/_communication/util.py,sha256=bJ3td3naDzmCelAJQpLwiDMoRBkijQl9YLROjsWyOrI,1256
+astreum/_consensus/__init__.py,sha256=gOCpvnIeO17CGjUGr0odaKNvGEggmDRXfT5IuyrYtcM,376
+astreum/_consensus/account.py,sha256=ClMB1e07ky5Wf7BwR4yhEjTSaWK2wiCmpvzio9AsZAY,3295
+astreum/_consensus/accounts.py,sha256=zGq2BCMJPtD_lzcj4jqMzB2Foc3ptxXSPhc9zypB1T0,1106
+astreum/_consensus/block.py,sha256=UfnB0JdzyDpC6BlNRRnj6yfWWzK3640BZflCRrwoqM4,12088
+astreum/_consensus/chain.py,sha256=WwUeLrdg7uj--ZsUxse6xFlzO2QeQQggyKSL49KhfU0,2768
+astreum/_consensus/fork.py,sha256=dK5DtT9hWCj_rQs6MS1c1bcGBbkgVTBPIOudYbqS9vw,3825
+astreum/_consensus/genesis.py,sha256=YOzEEcpH5lQUdRNz1P8cfeddh-IJzjTbOiVKrEPHXPg,2506
+astreum/_consensus/receipt.py,sha256=woUZmfqZIj6cEOFgM2wnh_tTb7u5IBqJcXdEIaIIAAM,4537
+astreum/_consensus/setup.py,sha256=KHW2KzHRgCMLWaJNV2utosKdk7nxjI5aF9ie7jctgcU,4257
+astreum/_consensus/transaction.py,sha256=KE3xcs0KkZQKTh-yr7DDsTMDIS82mpTQBJ_SZDZcy0g,7844
+astreum/_consensus/workers/__init__.py,sha256=bS5FjbevbIR5FHbVGnT4Jli17VIld_5auemRw4CaHFU,278
+astreum/_consensus/workers/discovery.py,sha256=X1yjKGjLSApMJ9mgWbnc7N21ALD09khDf-in-M45Mis,1683
+astreum/_consensus/workers/validation.py,sha256=ftlwTDocwrvCk_BAicrOJgm3deZHgwjN_gn5r-gWE_0,4900
+astreum/_consensus/workers/verify.py,sha256=wNkfh5qMARew79B-yyGL2UiExaSoGpOIq0fXUkDzpdw,1925
+astreum/_lispeum/__init__.py,sha256=LAy2Z-gBBQlByBHRGUKaaQrOB7QzFEEyGRtInmwTpfU,304
+astreum/_lispeum/environment.py,sha256=pJ0rjp9GoQxHhDiPIVei0jP7dZ_Pznso2O_tpp94-Ik,328
+astreum/_lispeum/expression.py,sha256=AJRSax65fKUb1v-fDrgJnKQOFbQVzO_XTSQ-qgECkcI,6797
+astreum/_lispeum/high_evaluation.py,sha256=Z0iSlx4IduhXwWghyflVpM1alKWOLAelqWvthe9rnhY,9554
+astreum/_lispeum/low_evaluation.py,sha256=j4QaUhBUCSdZVcVngQ__gUJL3FxvzyzEIcIox2J50B0,4538
+astreum/_lispeum/meter.py,sha256=5q2PFW7_jmgKVM1-vwE4RRjMfPEthUA4iu1CwR-Axws,505
+astreum/_lispeum/parser.py,sha256=Z_Y0Sax0rPh8JcIo19-iNDQoc5GTdGQkmfFyLpCB4bw,1757
+astreum/_lispeum/tokenizer.py,sha256=P68uIj4aPKzjuCJ85jfzRi67QztpuXIOC1vvLQueBI4,552
+astreum/_storage/__init__.py,sha256=14C37U3MC52oGWIp99tCC6mfWZPYBK9moapl0sXbTHI,104
+astreum/_storage/atom.py,sha256=14LKD-lYsHB0wjfCYrWzXEs-doalJuEwdMb9zuIZDw0,3106
+astreum/_storage/patricia.py,sha256=VPrTAE8aOvHCrY1dzrJ8IObbpEvL8bOefkp1YfLjeMM,16385
+astreum/_storage/setup.py,sha256=sgBrYUn2ljs-ntsliDyKa2KugZrLJwlqOc2Ikg_3WPs,1238
+astreum/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
+astreum/crypto/quadratic_form.py,sha256=pJgbORey2NTWbQNhdyvrjy_6yjORudQ67jBz2ScHptg,4037
+astreum/crypto/wesolowski.py,sha256=SUgGXW3Id07dJtWzDcs4dluIhjqbRWQ8YWjn_mK78AQ,4092
+astreum/crypto/x25519.py,sha256=i29v4BmwKRcbz9E7NKqFDQyxzFtJUqN0St9jd7GS1uA,1137
+astreum/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/models/block.py,sha256=_dgas0zW9OLFV7C1Bo-laxa102klqpJrCAG3DnwQ51U,18092
+astreum/models/merkle.py,sha256=lvWJa9nmrBL0n_2h_uNqpB_9a5s5Hn1FceRLx0IZIVQ,6778
+astreum/models/patricia.py,sha256=ohmXrcaz7Ae561tyC4u4iPOkQPkKr8N0IWJek4upFIg,13392
+astreum/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/storage/object.py,sha256=knFlvw_tpcC4twSu1DGNpHX31wlANN8E5dgEqIfU--Q,2041
+astreum/storage/setup.py,sha256=1-9ztEFI_BvRDvAA0lAn4mFya8iq65THTArlj--M3Hg,626
+astreum/utils/bytes.py,sha256=9QTWC2JCdwWLB5R2mPtmjPro0IUzE58DL3uEul4AheE,846
+astreum/utils/integer.py,sha256=iQt-klWOYVghu_NOT341MmHbOle4FDT3by4PNKNXscg,736
+astreum/utils/logging.py,sha256=mRDtWSCj8vKt58WGKLNSkK9Oa0graNVSoS8URby4Q9g,6684
+astreum-0.2.61.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.61.dist-info/METADATA,sha256=lZdmBEvNYJxK5iWuYpIXo5PUX8zOqfqMx8n7YRHhvvY,7726
+astreum-0.2.61.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.61.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.61.dist-info/RECORD,,

astreum/lispeum/__init__.py

@@ -1,2 +0,0 @@
-from .parser import parse
-from .tokenizer import tokenize

astreum/lispeum/environment.py

@@ -1,40 +0,0 @@
-from typing import Dict, Optional
-import uuid
-
-from astreum.lispeum.expression import Expr
-
-
-class Env:
-    def __init__(
-        self,
-        data: Optional[Dict[str, Expr]] = None,
-        parent_id: Optional[uuid.UUID] = None,
-        max_exprs: Optional[int] = 8,
-    ):
-        self.data: Dict[str, Expr] = data if data is not None else {}
-        self.parent_id: Optional[uuid.UUID] = parent_id
-        self.max_exprs: Optional[int] = max_exprs
-
-    def put(self, name: str, value: Expr) -> None:
-        if (
-            self.max_exprs is not None
-            and name not in self.data
-            and len(self.data) >= self.max_exprs
-        ):
-            raise RuntimeError(
-                f"environment full: {len(self.data)} ≥ max_exprs={self.max_exprs}"
-            )
-        self.data[name] = value
-
-    def get(self, name: str) -> Optional[Expr]:
-        return self.data.get(name)
-
-    def pop(self, name: str) -> Optional[Expr]:
-        return self.data.pop(name, None)
-
-    def __repr__(self) -> str:
-        return (
-            f"Env(size={len(self.data)}, "
-            f"max_exprs={self.max_exprs}, "
-            f"parent_id={self.parent_id})"
-        )

astreum/lispeum/expression.py

@@ -1,86 +0,0 @@
-
-from typing import List, Optional, Union
-
-
-class Expr:
-    class ListExpr:
-        def __init__(self, elements: List['Expr']):
-            self.elements = elements
-
-        def __eq__(self, other):
-            if not isinstance(other, Expr.ListExpr):
-                return NotImplemented
-            return self.elements == other.elements
-
-        def __ne__(self, other):
-            return not self.__eq__(other)
-
-        @property
-        def value(self):
-            inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
-
-
-        def __repr__(self):
-            if not self.elements:
-                return "()"
-            
-            inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
-        
-        def __iter__(self):
-            return iter(self.elements)
-        
-        def __getitem__(self, index: Union[int, slice]):
-            return self.elements[index]
-
-        def __len__(self):
-            return len(self.elements)
-
-    class Symbol:
-        def __init__(self, value: str):
-            self.value = value
-
-        def __repr__(self):
-            return self.value
-
-    class Integer:
-        def __init__(self, value: int):
-            self.value = value
-
-        def __repr__(self):
-            return str(self.value)
-
-    class String:
-        def __init__(self, value: str):
-            self.value = value
-
-        def __repr__(self):
-            return f'"{self.value}"'
-        
-    class Boolean:
-        def __init__(self, value: bool):
-            self.value = value
-
-        def __repr__(self):
-            return "true" if self.value else "false"
-
-    class Function:
-        def __init__(self, params: List[str], body: 'Expr'):
-            self.params = params
-            self.body = body
-
-        def __repr__(self):
-            params_str = " ".join(self.params)
-            body_str = str(self.body)
-            return f"(fn ({params_str}) {body_str})"
-
-    class Error:
-        def __init__(self, message: str, origin: Optional['Expr'] = None):
-            self.message = message
-            self.origin  = origin
-
-        def __repr__(self):
-            if self.origin is None:
-                return f'(error "{self.message}")'
-            return f'(error "{self.message}" in {self.origin})'

astreum/lispeum/parser.py

@@ -1,41 +0,0 @@
-from typing import List, Tuple
-from ..node import Expr
-
-class ParseError(Exception):
-    pass
-
-def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:
-    if not tokens:
-        raise ParseError("Unexpected end of input")
-
-    first_token, *rest = tokens
-
-    if first_token == '(':
-        if not rest:
-            raise ParseError("Expected token after '('")
-
-        list_items = []
-        inner_tokens = rest
-
-        while inner_tokens:
-            if inner_tokens[0] == ')':
-                return Expr.ListExpr(list_items), inner_tokens[1:]
-
-            expr, inner_tokens = parse(inner_tokens)
-            list_items.append(expr)
-
-        raise ParseError("Expected closing ')'")
-
-    elif first_token == ')':
-        raise ParseError("Unexpected closing parenthesis")
-
-    elif first_token.startswith('"') and first_token.endswith('"'):
-        string_content = first_token[1:-1]
-        return Expr.String(string_content), rest
-
-    else:
-        try:
-            number = int(first_token)
-            return Expr.Integer(number), rest
-        except ValueError:
-            return Expr.Symbol(first_token), rest

astreum/lispeum/tokenizer.py

@@ -1,52 +0,0 @@
-
-
-# Tokenizer function
-from typing import List
-
-class ParseError(Exception):
-    pass
-
-def tokenize(input: str) -> List[str]:
-    tokens = []
-    current_token = ""
-    in_string = False
-    escape = False
-
-    for char in input:
-        if in_string:
-            if escape:
-                current_token += char
-                escape = False
-            elif char == '\\':
-                escape = True
-            elif char == '"':
-                in_string = False
-                tokens.append(f'"{current_token}"')
-                current_token = ""
-            else:
-                current_token += char
-        else:
-            if char.isspace():
-                if current_token:
-                    tokens.append(current_token)
-                    current_token = ""
-            elif char == '(' or char == ')':
-                if current_token:
-                    tokens.append(current_token)
-                    current_token = ""
-                tokens.append(char)
-            elif char == '"':
-                if current_token:
-                    tokens.append(current_token)
-                    current_token = ""
-                in_string = True
-            else:
-                current_token += char
-
-    if in_string:
-        raise ParseError("Unterminated string literal")
-
-    if current_token:
-        tokens.append(current_token)
-
-    return tokens