ndnc 0.0.1__tar.gz

ndnc-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tryuuu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ndnc-0.0.1/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: ndnc
+Version: 0.0.1
+Summary: A DSL interpreter for transparent distributed execution over NDN
+Author-email: tryuuu <ryu23210@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tryuuu/ndn-compiler
+Project-URL: Repository, https://github.com/tryuuu/ndn-compiler
+Keywords: ndn,dsl,distributed,icn
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lark==1.1.9
+Requires-Dist: python-ndn
+Dynamic: license-file
+
+# Description
+A minimal domain-specific language (DSL) interpreter for NDN-less syntax.  
+Currently supports several simple operations.
+# Setup
+## Start Environment (Docker)
+Build and start NFD and Producer containers.
+```bash
+make all
+```
+## Run examples
+Run the consumer in a container.
+```bash
+make run
+```
+
+ローカル関数（`modify`）の動作確認:
+```bash
+make run S=examples/hello.ndn
+# 出力例: local data from function
+```
+
+リモート関数（`remote_modify`）の動作確認:
+```bash
+make run S=examples/remote.ndn
+# 出力例: local data from remote_modify
+```
+
+`remote_modify` は NDN Interest `/remote_modify/<arg>` を発行し、`remote_modify` コンテナが処理を行う。`make all` 実行時に自動で起動する。
+## Check Logs
+```bash
+make logs
+```
+## Stop Environment
+```bash
+make down
+```

ndnc-0.0.1/README.md

@@ -0,0 +1,36 @@
+# Description
+A minimal domain-specific language (DSL) interpreter for NDN-less syntax.  
+Currently supports several simple operations.
+# Setup
+## Start Environment (Docker)
+Build and start NFD and Producer containers.
+```bash
+make all
+```
+## Run examples
+Run the consumer in a container.
+```bash
+make run
+```
+
+ローカル関数（`modify`）の動作確認:
+```bash
+make run S=examples/hello.ndn
+# 出力例: local data from function
+```
+
+リモート関数（`remote_modify`）の動作確認:
+```bash
+make run S=examples/remote.ndn
+# 出力例: local data from remote_modify
+```
+
+`remote_modify` は NDN Interest `/remote_modify/<arg>` を発行し、`remote_modify` コンテナが処理を行う。`make all` 実行時に自動で起動する。
+## Check Logs
+```bash
+make logs
+```
+## Stop Environment
+```bash
+make down
+```

ndnc-0.0.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+    requires = ["setuptools>=68", "wheel"]
+    build-backend = "setuptools.build_meta"
+
+
+[project]
+    name = "ndnc"
+    version = "0.0.1"
+    description = "A DSL interpreter for transparent distributed execution over NDN"
+    authors = [{ name = "tryuuu", email = "ryu23210@gmail.com" }]
+    readme = "README.md"
+    license = "MIT"
+    license-files = ["LICENSE"]
+    requires-python = ">=3.10"
+    dependencies = [
+        "lark==1.1.9",
+        "python-ndn"
+    ]
+    keywords = ["ndn", "dsl", "distributed", "icn"]
+    classifiers = [
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Software Development :: Interpreters",
+    ]
+
+[project.urls]
+    Homepage = "https://github.com/tryuuu/ndn-compiler"
+    Repository = "https://github.com/tryuuu/ndn-compiler"
+
+[project.scripts]
+    ndnc = "ndnc.cli:main"
+
+[tool.setuptools.package-data]
+"ndnc.parser" = ["*.lark"]

ndnc-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ndnc-0.0.1/src/ndnc/__init__.py

@@ -0,0 +1 @@
+__all__ = []

ndnc-0.0.1/src/ndnc/cli.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+import argparse
+from pathlib import Path
+from .parser.parser import parse
+from .interp.evaluator import Interpreter
+from .server import Server
+
+def main():
+    ap = argparse.ArgumentParser(prog="ndnc", description="NDN-less minimal DSL interpreter (print only)")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    ap_run = sub.add_parser("run", help="Interpret and run a .ndn file")
+    ap_run.add_argument("source", type=Path)
+    ap_run.add_argument("ndn_args", nargs="*", metavar="ARG",
+                        help="NDN names passed as arg0, arg1, ... to the script")
+
+    ap_serve = sub.add_parser("serve", help="Start NDN server (producer)")
+
+    args = ap.parse_args()
+
+    if args.cmd == "run":
+        code = args.source.read_text(encoding="utf-8")
+        prog = parse(code)
+        # 位置引数を arg0, arg1, ... として Interpreter に渡す
+        ndn_args = {f"arg{i}": v for i, v in enumerate(args.ndn_args)}
+        Interpreter(args=ndn_args).run(prog)
+    elif args.cmd == "serve":
+        Server().run()
+
+
+if __name__ == "__main__":
+    main()

ndnc-0.0.1/src/ndnc/interp/evaluator.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+from typing import Any, Union, Optional
+import asyncio
+import contextlib
+import io
+import traceback
+import sys
+from ndn.app import NDNApp
+from ndn.encoding import Name
+from ndn.security import KeychainDigest
+from ..parser.ast import (
+	Program, PrintStatement, Assignment, ExprStatement,
+	StringLiteral, NumberLiteral, Variable,
+	ExpressInterest, FunctionCall, Expr
+)
+
+# ローカルで処理できる関数名のセット
+_LOCAL_FUNCTIONS = {"modify", "concat"}
+
+class Interpreter:
+    def __init__(self, args: dict[str, str] | None = None):
+        self._env: dict[str, Any] = {}
+        self._env_origin: dict[str, str] = {}  # interest で取得した変数の NDN 名を追跡
+        # 外部から渡された引数を env に事前登録（例: {"arg0": "/data/ryu-local/"}）
+        if args:
+            self._env.update(args)
+        self.app: Optional[NDNApp] = None
+        self._local_data: dict[str, str] = {
+            '/data/ryu-local/': 'local data',
+            '/height/Mt.Fuji/': '3776m',
+        }
+
+    def run(self, program: Program):
+        has_interest = any(
+            (isinstance(st, ExprStatement) and self._has_interest(st.expr)) or
+            (isinstance(st, PrintStatement) and self._has_interest(st.expr)) or
+            (isinstance(st, Assignment) and self._has_interest(st.expr))
+            for st in program
+        )
+
+        if has_interest:
+            try:
+                self.app = NDNApp(keychain=KeychainDigest())
+                # ローカルデータを NDN プロデューサーとして登録する
+                # （リモート関数がこれらをフェッチできるようにするため）
+                self._register_local_data_routes()
+
+                async def after_start():
+                    try:
+                        await self._exec_block(program)
+                    except Exception:
+                        traceback.print_exc()
+                        raise
+                    finally:
+                        self.app.shutdown()
+
+                self.app.run_forever(after_start=after_start())
+
+            except Exception as e:
+                print(f"DEBUG: NDN Connection/Execution Failed: {e}")
+                traceback.print_exc()
+                self.app = None
+                asyncio.run(self._exec_block(program))
+        else:
+            asyncio.run(self._exec_block(program))
+
+    def _has_interest(self, expr: Expr) -> bool:
+        if isinstance(expr, ExpressInterest):
+            if expr.name_is_var:
+                # 変数の値は実行時まで不明なのでネットワーク必要とみなす
+                return True
+            # _local_data にあればネットワーク不要
+            return expr.name not in self._local_data
+        if isinstance(expr, Variable):
+            return False
+        if isinstance(expr, FunctionCall):
+            # ローカルにない関数はリモート呼び出しになるため NDNApp が必要
+            return (expr.name not in _LOCAL_FUNCTIONS) or any(self._has_interest(a) for a in expr.args)
+        return False
+
+    async def _exec_block(self, node: Program):
+        for st in node:
+            if isinstance(st, PrintStatement):
+                await self._exec_print(st)
+            elif isinstance(st, Assignment):
+                await self._exec_assignment(st)
+            elif isinstance(st, ExprStatement):
+                await self._exec_expr_stmt(st)
+            else:
+                raise RuntimeError(f"Unsupported node: {st}")
+
+    async def _exec_print(self, node: PrintStatement):
+        value = await self._eval_expr(node.expr)
+        print(value)
+
+    async def _exec_assignment(self, node: Assignment):
+        value = await self._eval_expr(node.expr)
+        self._env[node.name] = value
+        # interest で取得した変数は NDN 名を記録しておく
+        if isinstance(node.expr, ExpressInterest):
+            if node.expr.name_is_var:
+                # 変数名から実際の NDN 名を解決して記録
+                ndn_name = self._env.get(node.expr.name, "")
+                self._env_origin[node.name] = str(ndn_name)
+            else:
+                self._env_origin[node.name] = node.expr.name
+
+    async def _exec_expr_stmt(self, node: ExprStatement):
+        value = await self._eval_expr(node.expr)
+        print(value)
+
+    async def _eval_expr(self, expr: Expr) -> Union[int, str]:
+        if isinstance(expr, StringLiteral):
+            return expr.value
+
+        if isinstance(expr, NumberLiteral):
+            return expr.value
+
+        if isinstance(expr, Variable):
+            if expr.name not in self._env:
+                raise RuntimeError(f"Variable '{expr.name}' is not defined")
+            return self._env[expr.name]
+
+        if isinstance(expr, ExpressInterest):
+            # name_is_var のとき、変数から実際の NDN 名を解決する
+            if expr.name_is_var:
+                if expr.name not in self._env:
+                    raise RuntimeError(f"Variable '{expr.name}' is not defined (used in interest)")
+                ndn_name = str(self._env[expr.name])
+            else:
+                ndn_name = expr.name
+
+            if not ndn_name.endswith('/'):
+                print(f"Error: Interest name must end with a trailing slash. Got: {ndn_name}", file=sys.stderr)
+                print(f"Expected: {ndn_name}/", file=sys.stderr)
+                sys.exit(1)
+
+            if ndn_name in self._local_data:
+                local_value = self._local_data[ndn_name]
+                try:
+                    return int(local_value)
+                except ValueError:
+                    return local_value
+
+            if self.app is None:
+                return f"mock_{ndn_name.replace('/', '_')}"
+
+            try:
+                _, _, content = await self.app.express_interest(
+                    ndn_name,
+                    must_be_fresh=True,
+                    can_be_prefix=True,
+                    lifetime=6000
+                )
+                if content is None:
+                    return ""
+                text = bytes(content).decode('utf-8').strip()
+                try:
+                    return int(text)
+                except ValueError:
+                    return text
+            except Exception as e:
+                print(f"Error expressing interest for {expr.name}: {e}")
+                raise e
+
+        if isinstance(expr, FunctionCall):
+            if expr.name in _LOCAL_FUNCTIONS:
+                arg_values = [await self._eval_expr(a) for a in expr.args]
+                if expr.name == "m_to_feet":
+                    meters_str = str(arg_values[0]).rstrip('m')
+                    feet = round(float(meters_str) * 3.28084)
+                    return f"{feet}ft"
+                if expr.name == "concat":
+                    return "".join(str(v) for v in arg_values)
+                return str(arg_values[0]) + " from function"
+            elif self.app is not None:
+                # リモート関数: 引数を NDN 名として渡す（ネストした関数呼び出しも再帰的に解決）
+                ndn_names = [self._to_ndn_name(a) for a in expr.args]
+                return await self._call_remote_function(expr.name, ndn_names)
+            else:
+                raise RuntimeError(f"Unknown function: {expr.name}")
+
+        raise RuntimeError(f"Unsupported expr: {expr}")
+
+    def _register_local_data_routes(self):
+        """ローカルデータを NDN プロデューサーとして登録する。
+        リモート関数がフェッチできるよう、Interest に応答できるようにする。"""
+        for ndn_name, value in self._local_data.items():
+            prefix = ndn_name.rstrip('/')
+            val_bytes = str(value).encode()
+
+            def make_handler(content):
+                def handler(name, param, app_param):
+                    self.app.put_data(name, content=content, freshness_period=10000)
+                return handler
+
+            self.app.route(prefix)(make_handler(val_bytes))
+
+    def _to_ndn_name(self, expr: Expr) -> str:
+        """リモート関数の引数として使う NDN 名を決定する。
+        - ExpressInterest → そのまま NDN 名を返す
+        - Variable → interest 由来なら記録済みの NDN 名、そうでなければ値を NDN 名として扱う
+        - StringLiteral → 先頭 '/' を補完して NDN 名とする"""
+        if isinstance(expr, ExpressInterest):
+            if expr.name_is_var:
+                if expr.name in self._env_origin:
+                    return self._env_origin[expr.name]
+                val = self._env.get(expr.name, "")
+                return str(val) if str(val).startswith('/') else '/' + str(val)
+            return expr.name
+        if isinstance(expr, Variable):
+            if expr.name in self._env_origin:
+                return self._env_origin[expr.name]
+            val = self._env.get(expr.name, "")
+            if isinstance(val, str):
+                return val if val.startswith('/') else '/' + val
+            return str(val)
+        if isinstance(expr, StringLiteral):
+            val = expr.value
+            return val if val.startswith('/') else '/' + val
+        if isinstance(expr, FunctionCall):
+            if expr.name not in _LOCAL_FUNCTIONS:
+                ndn_names = [self._to_ndn_name(a) for a in expr.args]
+                args_str = ", ".join(ndn_names)
+                return "/" + expr.name + "/(" + args_str + ")"
+        return str(expr)
+
+    async def _call_remote_function(self, func_name: str, ndn_names: list[str]) -> str:
+        # Sidecar に倣い、括弧記法で Interest 名を構築する
+        # 例: /temperature_average/(/data/tokyo, /data/paris)
+        args_str = ", ".join(ndn_names)
+        interest_name = "/" + func_name + "/(" + args_str + ")"
+        try:
+            _, _, content = await self.app.express_interest(
+                interest_name,
+                must_be_fresh=True,
+                can_be_prefix=False,
+                lifetime=20000  # リモート関数が引数をフェッチする時間を考慮して長めに設定
+            )
+            if content is None:
+                return ""
+            return bytes(content).decode('utf-8').strip()
+        except Exception as e:
+            print(f"Error calling remote function '{func_name}': {e}")
+            raise
+
+    async def exec_in_context(self, program: Program, app: NDNApp) -> str:
+        """既存の NDNApp のコンテキスト内で .ndn プログラムを実行し、出力を文字列で返す。
+        seed サーバーなど、すでにイベントループが動いている環境から呼び出す用途向け。
+        通常の run() と異なり、新たなイベントループや NDNApp を起動しない。"""
+        self.app = app
+        buffer = io.StringIO()
+        with contextlib.redirect_stdout(buffer):
+            await self._exec_block(program)
+        return buffer.getvalue().strip()

ndnc-0.0.1/src/ndnc/parser/__init__.py

@@ -0,0 +1 @@
+__all__ = []

ndnc-0.0.1/src/ndnc/parser/ast.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Union
+
+
+@dataclass
+class PrintStatement:
+	expr: "Expr"
+
+@dataclass
+class Assignment:
+	name: str
+	expr: "Expr"
+
+@dataclass
+class StringLiteral:
+	value: str
+
+@dataclass
+class NumberLiteral:
+	value: int
+
+@dataclass
+class Variable:
+	name: str
+
+@dataclass
+class ExpressInterest:
+	name: str
+	name_is_var: bool = False  # True のとき name は変数名（実行時に env から解決する）
+
+@dataclass
+class FunctionCall:
+	name: str
+	args: List["Expr"]
+
+Expr = Union[StringLiteral, NumberLiteral, Variable, ExpressInterest, FunctionCall]
+
+@dataclass
+class ExprStatement:
+	expr: Expr
+
+
+Statement = Union[PrintStatement, Assignment, ExprStatement]
+Program = List[Statement]

ndnc-0.0.1/src/ndnc/parser/grammar.lark

@@ -0,0 +1,26 @@
+// Simple grammar: only print statements of string literals
+
+start: statement+
+
+// 定義できる文法
+?statement: LET IDENTIFIER "=" expr    -> assignment_stmt
+         | PRINT expr                   -> print_stmt
+         | expr                         -> expr_stmt
+
+// exprの種類を定義
+?expr: STRING                                    -> string_literal
+     | NUMBER                                    -> number_literal
+     | IDENTIFIER "(" expr ("," expr)* ")"       -> call_expr
+     | IDENTIFIER                                -> variable
+     | INTEREST STRING                           -> interest_expr
+     | INTEREST IDENTIFIER                       -> interest_var_expr
+
+LET: "let"
+PRINT: "print"
+INTEREST: "interest"
+IDENTIFIER: /[a-zA-Z_][a-zA-Z0-9_]*/
+
+%import common.ESCAPED_STRING -> STRING
+%import common.SIGNED_NUMBER  -> NUMBER
+%import common.WS
+%ignore WS

ndnc-0.0.1/src/ndnc/parser/parser.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+from lark import Lark, Transformer, v_args
+
+from .ast import (
+	PrintStatement, Assignment, ExprStatement,
+	StringLiteral, NumberLiteral, Variable,
+	ExpressInterest, FunctionCall, Program, Expr
+)
+
+
+def _load_grammar() -> str:
+	grammar_path = Path(__file__).with_name("grammar.lark")
+	return grammar_path.read_text(encoding="utf-8")
+
+
+_PARSER = Lark(_load_grammar(), start="start", parser="lalr")
+
+
+class _BuildAST(Transformer):
+	@v_args(inline=True)
+	def assignment_stmt(self, let_token, identifier_token, expr: Expr):  # type: ignore[override]
+		name = str(identifier_token)
+		return Assignment(name=name, expr=expr)
+
+	@v_args(inline=True)
+	def print_stmt(self, print_token, expr: Expr):  # type: ignore[override]
+		return PrintStatement(expr=expr)
+
+	@v_args(inline=True)
+	def expr_stmt(self, expr: Expr):  # type: ignore[override]
+		return ExprStatement(expr=expr)
+
+	@v_args(inline=True)
+	def string_literal(self, string_token):  # type: ignore[override]
+		text = str(string_token)
+		if (text.startswith('"') and text.endswith('"')) or (text.startswith("'") and text.endswith("'")):
+			text = text[1:-1]
+		return StringLiteral(value=text)
+
+	@v_args(inline=True)
+	def number_literal(self, num_token):  # type: ignore[override]
+		return NumberLiteral(value=int(str(num_token)))
+
+	@v_args(inline=True)
+	def variable(self, identifier_token):  # type: ignore[override]
+		name = str(identifier_token)
+		return Variable(name=name)
+
+	@v_args(inline=True)
+	def interest_expr(self, interest_token, string_token):  # type: ignore[override]
+		text = str(string_token)
+		if (text.startswith('"') and text.endswith('"')) or (text.startswith("'") and text.endswith("'")):
+			text = text[1:-1]
+		return ExpressInterest(name=text)
+
+	@v_args(inline=True)
+	def interest_var_expr(self, interest_token, identifier_token):  # type: ignore[override]
+		return ExpressInterest(name=str(identifier_token), name_is_var=True)
+
+	def call_expr(self, items):  # type: ignore[override]
+		name = str(items[0])
+		args = list(items[1:])
+		return FunctionCall(name=name, args=args)
+
+	def start(self, stmts):  # type: ignore[override]
+		if isinstance(stmts, list):
+			return stmts
+		else:
+			return [stmts]
+
+def parse(source: str) -> Program:
+	tree = _PARSER.parse(source)
+	program: Program = _BuildAST().transform(tree)
+	return program

ndnc-0.0.1/src/ndnc/remote_modify.py

@@ -0,0 +1,222 @@
+import asyncio
+import urllib.parse
+from typing import Optional
+from ndn.app import NDNApp
+from ndn.encoding import Name, InterestParam, BinaryStr, FormalName
+from ndn.security import KeychainDigest
+from ndn.types import InterestNack, InterestTimeout
+
+import logging
+logging.basicConfig(format='[{asctime}]{levelname}:{message}',
+                    datefmt='%Y-%m-%d %H:%M:%S',
+                    level=logging.INFO,
+                    style='{')
+
+_TEMPERATURE_DATA: dict[str, float] = {
+    '/data/tokyo':   22.5,
+    '/data/paris':   18.0,
+    '/data/newyork': 15.3,
+    '/data/london':  12.8,
+    '/data/sydney':  26.1,
+}
+
+app = NDNApp(keychain=KeychainDigest())
+
+
+def decode_and_remove_metadata(name: FormalName) -> str:
+    """NDN FormalName をデコードし、/t= などのメタデータを除去して返す。"""
+    decoded = Name.to_str(name)
+    decoded = urllib.parse.unquote(decoded)
+    # ')' の直後に '/' が続く場合はそこで打ち切る
+    end = decoded.rfind(')')
+    if end != -1 and len(decoded) > end + 1 and decoded[end + 1] == '/':
+        decoded = decoded[:end + 1]
+    # /t= メタデータを除去
+    t_idx = decoded.rfind('/t=')
+    if t_idx != -1:
+        decoded = decoded[:t_idx]
+    return decoded
+
+
+def is_function_request(name: FormalName) -> bool:
+    """/( が含まれていれば関数リクエストと判定する。"""
+    return "/(" in decode_and_remove_metadata(name)
+
+
+def extract_first_level_args(name: FormalName) -> list[str]:
+    """関数 Interest から第一階層の引数（NDN 名）リストを取り出す。
+    ネストした括弧にも対応。例: /f/(/a, /g/(/b)) → ['/a', '/g/(/b)']"""
+    decoded = decode_and_remove_metadata(name)
+    if '(' not in decoded:
+        return [decoded.strip()]
+
+    start_of_args = decoded.find('/(') + 2   # '(' の直後
+    args_str = decoded[start_of_args:-1]      # 末尾の ')' を除く
+
+    args: list[str] = []
+    start = 0
+    depth = 0
+    for i, ch in enumerate(args_str):
+        if ch == '(':
+            depth += 1
+        elif ch == ')':
+            depth -= 1
+        elif ch == ',' and depth == 0:
+            args.append(args_str[start:i].strip())
+            start = i + 1
+    args.append(args_str[start:].strip())
+    return args
+
+
+async def _fetch_arg(ndn_name: str) -> Optional[bytes]:
+    """引数の NDN 名を解決する。
+    ローカルデータストアを先に確認し、なければ consumer_app で Interest を発行する。
+    引数がネストした関数呼び出しの場合も再帰的に解決される。"""
+    key = ndn_name.rstrip('/')
+    if key in _TEMPERATURE_DATA:
+        logging.info(f"[local] {key} = {_TEMPERATURE_DATA[key]}")
+        return str(_TEMPERATURE_DATA[key]).encode()
+
+    # NDN ネットワーク経由で取得（ネストした関数呼び出しを含む）
+    logging.info(f"[fetch] {ndn_name}")
+    for attempt in range(3):
+        try:
+            _, _, content = await app.express_interest(
+                ndn_name, must_be_fresh=True, can_be_prefix=False, lifetime=10000
+            )
+            if content:
+                logging.info(f"[fetch] OK {ndn_name} (attempt {attempt + 1})")
+                return bytes(content)
+        except (InterestNack, InterestTimeout) as e:
+            logging.warning(f"[fetch] {ndn_name} attempt {attempt + 1} failed: {e}")
+        await asyncio.sleep(0.3)
+    logging.error(f"[fetch] GIVE-UP {ndn_name}")
+    return None
+
+
+@app.route('/data')
+def on_data(name: FormalName, param: InterestParam, _app_param: Optional[BinaryStr]):
+    """データリクエストに応答する（/data/* プレフィックス）。"""
+    name_str = Name.to_str(name)
+    t_idx = name_str.rfind('/t=')
+    if t_idx != -1:
+        name_str = name_str[:t_idx]
+    key = name_str.rstrip('/')
+    if key in _TEMPERATURE_DATA:
+        logging.info(f"Serving data: {key}")
+        app.put_data(name, content=str(_TEMPERATURE_DATA[key]).encode(), freshness_period=10000)
+    else:
+        logging.warning(f"Unknown data key: {key}")
+
+
+@app.route('/remote_modify')
+def on_modify(name: FormalName, param: InterestParam, _app_param: Optional[BinaryStr]):
+    async def handler():
+        logging.info(f"Interest: {Name.to_str(name)}")
+        if not is_function_request(name):
+            logging.warning("Not a function request")
+            return
+
+        args = extract_first_level_args(name)
+        logging.info(f"Args: {args}")
+
+        contents = await asyncio.gather(*[_fetch_arg(a) for a in args])
+        if any(c is None for c in contents):
+            app.put_data(name, content=b"error: failed to fetch argument", freshness_period=10000)
+            return
+
+        result = f"{contents[0].decode()} from remote_modify"
+        logging.info(f"Result: {result!r}")
+        app.put_data(name, content=result.encode(), freshness_period=10000)
+
+    asyncio.create_task(handler())
+
+
+@app.route('/temperature_average')
+def on_temperature_average(name: FormalName, param: InterestParam, _app_param: Optional[BinaryStr]):
+    async def handler():
+        logging.info(f"Interest: {Name.to_str(name)}")
+        if not is_function_request(name):
+            logging.warning("Not a function request")
+            return
+
+        args = extract_first_level_args(name)
+        logging.info(f"Args: {args}")
+
+        contents = await asyncio.gather(*[_fetch_arg(a) for a in args])
+        if any(c is None for c in contents):
+            app.put_data(name, content=b"error: failed to fetch argument(s)", freshness_period=10000)
+            return
+
+        try:
+            temps = [float(c.decode()) for c in contents]
+            average = sum(temps) / len(temps)
+            result = f"{average:.1f}"
+            logging.info(f"temperature_average{tuple(args)} = {result}")
+            app.put_data(name, content=result.encode(), freshness_period=10000)
+        except ValueError as e:
+            app.put_data(name, content=f"error: {e}".encode(), freshness_period=10000)
+
+    asyncio.create_task(handler())
+
+
+@app.route('/format_temp')
+def on_format_temp(name: FormalName, param: InterestParam, _app_param: Optional[BinaryStr]):
+    async def handler():
+        logging.info(f"Interest: {Name.to_str(name)}")
+        if not is_function_request(name):
+            logging.warning("Not a function request")
+            return
+
+        args = extract_first_level_args(name)
+        logging.info(f"Args: {args}")
+
+        contents = await asyncio.gather(*[_fetch_arg(a) for a in args])
+        if any(c is None for c in contents):
+            app.put_data(name, content=b"error: failed to fetch argument", freshness_period=10000)
+            return
+
+        result = f"{contents[0].decode()}°C"
+        logging.info(f"Result: {result!r}")
+        app.put_data(name, content=result.encode(), freshness_period=10000)
+
+    asyncio.create_task(handler())
+
+
+@app.route('/m_to_feet')
+def on_m_to_feet(name: FormalName, param: InterestParam, _app_param: Optional[BinaryStr]):
+    async def handler():
+        logging.info(f"Interest: {Name.to_str(name)}")
+        if not is_function_request(name):
+            logging.warning("Not a function request")
+            return
+
+        args = extract_first_level_args(name)
+        logging.info(f"Args: {args}")
+
+        contents = await asyncio.gather(*[_fetch_arg(a) for a in args])
+        if any(c is None for c in contents):
+            app.put_data(name, content=b"error: failed to fetch argument", freshness_period=10000)
+            return
+
+        try:
+            meters_str = contents[0].decode().rstrip('m')
+            feet = round(float(meters_str) * 3.28084)
+            result = f"{feet}ft"
+            logging.info(f"Result: {result!r}")
+            app.put_data(name, content=result.encode(), freshness_period=10000)
+        except ValueError as e:
+            app.put_data(name, content=f"error: {e}".encode(), freshness_period=10000)
+
+    asyncio.create_task(handler())
+
+
+if __name__ == '__main__':
+    print("Starting remote function node")
+    print(f"  /remote_modify       : /remote_modify/(<arg>)")
+    print(f"  /temperature_average : /temperature_average/(<name1>, <name2>, ...)")
+    print(f"  /format_temp         : /format_temp/(<temp_value_or_func>)")
+    print(f"  /m_to_feet           : /m_to_feet/(<meters_value>)")
+    print(f"  /data/*              : temperature data")
+    print(f"  Available data: {list(_TEMPERATURE_DATA.keys())}")
+    app.run_forever()

ndnc-0.0.1/src/ndnc/server.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import sys
+
+from ndn.app import NDNApp
+from ndn.encoding import Name
+from ndn.security import KeychainDigest
+
+
+class Server:
+    def __init__(self):
+        try:
+            self.app = NDNApp(keychain=KeychainDigest())
+        except Exception as e:
+            print(f"Error: Failed to initialize NDNApp: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def run(self):
+        @self.app.route('/data/ryu')
+        def on_data_ryu(name, param, _app_param):
+            print(f"Received Interest: {Name.to_str(name)}")
+            self.app.put_data(name, content=b'success', freshness_period=10000)
+            print(f"Sent Data: {Name.to_str(name)} -> success")
+        print("Server started. Listening for Interests on /data/ryu...")
+
+        @self.app.route('/data/nakazatolab')
+        def on_data_nakazatolab(name, param, _app_param):
+            print(f"Received Interest: {Name.to_str(name)}")
+            self.app.put_data(name, content=b'NDN research', freshness_period=10000)
+            print(f"Sent Data: {Name.to_str(name)} -> NDN research")
+        print("Server started. Listening for Interests on /data/nakazatolab...")
+
+        @self.app.route('/height/Mt.Fuji')
+        def on_height_mt_fuji(name, param, _app_param):
+            print(f"Received Interest: {Name.to_str(name)}")
+            self.app.put_data(name, content=b'3776m', freshness_period=10000)
+            print(f"Sent Data: {Name.to_str(name)} -> 3776m")
+        print("Server started. Listening for Interests on /height/Mt.Fuji...")
+
+        self.app.run_forever()

ndnc-0.0.1/src/ndnc.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: ndnc
+Version: 0.0.1
+Summary: A DSL interpreter for transparent distributed execution over NDN
+Author-email: tryuuu <ryu23210@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tryuuu/ndn-compiler
+Project-URL: Repository, https://github.com/tryuuu/ndn-compiler
+Keywords: ndn,dsl,distributed,icn
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lark==1.1.9
+Requires-Dist: python-ndn
+Dynamic: license-file
+
+# Description
+A minimal domain-specific language (DSL) interpreter for NDN-less syntax.  
+Currently supports several simple operations.
+# Setup
+## Start Environment (Docker)
+Build and start NFD and Producer containers.
+```bash
+make all
+```
+## Run examples
+Run the consumer in a container.
+```bash
+make run
+```
+
+ローカル関数（`modify`）の動作確認:
+```bash
+make run S=examples/hello.ndn
+# 出力例: local data from function
+```
+
+リモート関数（`remote_modify`）の動作確認:
+```bash
+make run S=examples/remote.ndn
+# 出力例: local data from remote_modify
+```
+
+`remote_modify` は NDN Interest `/remote_modify/<arg>` を発行し、`remote_modify` コンテナが処理を行う。`make all` 実行時に自動で起動する。
+## Check Logs
+```bash
+make logs
+```
+## Stop Environment
+```bash
+make down
+```

ndnc-0.0.1/src/ndnc.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/ndnc/__init__.py
+src/ndnc/cli.py
+src/ndnc/remote_modify.py
+src/ndnc/server.py
+src/ndnc.egg-info/PKG-INFO
+src/ndnc.egg-info/SOURCES.txt
+src/ndnc.egg-info/dependency_links.txt
+src/ndnc.egg-info/entry_points.txt
+src/ndnc.egg-info/requires.txt
+src/ndnc.egg-info/top_level.txt
+src/ndnc/interp/__init__.py
+src/ndnc/interp/evaluator.py
+src/ndnc/parser/__init__.py
+src/ndnc/parser/ast.py
+src/ndnc/parser/grammar.lark
+src/ndnc/parser/parser.py

ndnc-0.0.1/src/ndnc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ndnc-0.0.1/src/ndnc.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ndnc = ndnc.cli:main

ndnc-0.0.1/src/ndnc.egg-info/requires.txt

@@ -0,0 +1,2 @@
+lark==1.1.9
+python-ndn

ndnc-0.0.1/src/ndnc.egg-info/top_level.txt

@@ -0,0 +1 @@
+ndnc