rulea 1.0.0__py3-none-any.whl

rulea/__init__.py

@@ -0,0 +1,2 @@
+from .parser import parse_rule_file
+from .engine import RuleEngine

rulea/cli.py

@@ -0,0 +1,27 @@
+import argparse
+from .engine import RuleEngine
+import json
+import sys
+
+def main():
+    parser = argparse.ArgumentParser(description="Rulea CLI - check rules.")
+    parser.add_argument("rule_file", help=".rulea file path")
+    parser.add_argument("rule_name", help="Rule name to check")
+    parser.add_argument("--context", "-c", help="JSON string of context variables", default="{}")
+
+    args = parser.parse_args()
+
+    try:
+        context = json.loads(args.context)
+    except Exception as e:
+        print(f"Invalid JSON context: {e}")
+        sys.exit(1)
+
+    engine = RuleEngine(args.rule_file)
+    ok, reason = engine.check(args.rule_name, context)
+    if ok:
+        print("Rule passed ✅")
+        sys.exit(0)
+    else:
+        print(f"Rule denied ❌ Reason: {reason}")
+        sys.exit(1)

rulea/engine.py

@@ -0,0 +1,21 @@
+from .evaluator import SafeEvaluator
+from .parser import parse_rule_file
+
+class RuleEngine:
+    def __init__(self, rule_path):
+        self.rules = parse_rule_file(rule_path)
+
+    def check(self, rule_name, context):
+        rule = self.rules.get(rule_name)
+        if not rule:
+            return False, "No such rule"
+
+        expr = rule.get("when")
+        reason = rule.get("reason", "Permission denied")
+
+        try:
+            evaluator = SafeEvaluator(context)
+            result = evaluator.eval(expr)
+            return result, None if result else reason
+        except Exception as e:
+            return False, f"Rule error: {e}"

rulea/evaluator.py

@@ -0,0 +1,51 @@
+import ast
+
+class SafeEvaluator(ast.NodeVisitor):
+    ALLOWED = {
+        ast.Expression, ast.BoolOp, ast.BinOp, ast.UnaryOp,
+        ast.Compare, ast.Name, ast.Load, ast.Constant,
+        ast.And, ast.Or, ast.Not, ast.Eq, ast.NotEq, ast.Gt, ast.Lt,
+        ast.GtE, ast.LtE
+    }
+
+    def __init__(self, context):
+        self.context = context
+
+    def eval(self, expr):
+        tree = ast.parse(expr, mode='eval')
+        return self.visit(tree.body)
+
+    def visit(self, node):
+        if type(node) not in self.ALLOWED:
+            raise ValueError(f"Unsupported node: {type(node).__name__}")
+        return super().visit(node)
+
+    def visit_Name(self, node):
+        return self.context.get(node.id, None)
+
+    def visit_Constant(self, node):
+        return node.value
+
+    def visit_BoolOp(self, node):
+        vals = [self.visit(v) for v in node.values]
+        return all(vals) if isinstance(node.op, ast.And) else any(vals)
+
+    def visit_Compare(self, node):
+        left = self.visit(node.left)
+        for op, comp in zip(node.ops, node.comparators):
+            right = self.visit(comp)
+            if isinstance(op, ast.Eq) and not left == right:
+                return False
+            if isinstance(op, ast.NotEq) and not left != right:
+                return False
+            if isinstance(op, ast.Gt) and not left > right:
+                return False
+            if isinstance(op, ast.Lt) and not left < right:
+                return False
+        return True
+
+    def visit_UnaryOp(self, node):
+        operand = self.visit(node.operand)
+        if isinstance(node.op, ast.Not):
+            return not operand
+        raise ValueError("Unsupported unary operation")

rulea/model.py

@@ -0,0 +1 @@
+⠀

rulea/parser.py

@@ -0,0 +1,225 @@
+# parser.py
+def parse_rule_file(path: str):
+    rules = {}
+    current_rule = None
+    current_block = None
+    with open(path, 'r') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+
+            if line.startswith("rule "):
+                rule_name = line.split()[1].rstrip(":")
+                current_rule = {
+                    "when": "",
+                    "reason": "",
+                    "imports": [],
+                    "description": "",
+                    "tags": [],
+                    "priority": 100,
+                    "action": "",
+                    "extends": None,
+                    "enabled": True
+                }
+                rules[rule_name] = current_rule
+
+            elif current_rule is None:
+                continue  # ファイル先頭にルール外の行があった場合スキップ
+
+            elif line.startswith("when:"):
+                current_block = "when"
+                current_rule["when"] = line[len("when:"):].strip()
+
+            elif line.startswith("reason:"):
+                current_block = "reason"
+                current_rule["reason"] = line[len("reason:"):].strip()
+
+            elif line.startswith("description:"):
+                current_rule["description"] = line[len("description:"):].strip()
+
+            elif line.startswith("tags:"):
+                current_rule["tags"] = [tag.strip() for tag in line[len("tags:"):].split(",")]
+
+            elif line.startswith("priority:"):
+                current_rule["priority"] = int(line[len("priority:"):].strip())
+
+            elif line.startswith("action:"):
+                current_block = "action"
+                current_rule["action"] = line[len("action:"):].strip()
+
+            elif line.startswith("import:"):
+                current_rule["imports"] = [x.strip() for x in line[len("import:"):].split(",")]
+
+            elif line.startswith("extends:"):
+                current_rule["extends"] = line[len("extends:"):].strip()
+
+            elif line.startswith("enabled:"):
+                val = line[len("enabled:"):].strip().lower()
+                current_rule["enabled"] = val in ("true", "yes", "1")
+
+            else:
+                if current_block:
+                    current_rule[current_block] += "\n" + line
+    return rules
+
+
+# evaluator.py
+import ast
+
+class SafeEvaluator(ast.NodeVisitor):
+    ALLOWED = {
+        ast.Expression, ast.BoolOp, ast.BinOp, ast.UnaryOp,
+        ast.Compare, ast.Name, ast.Load, ast.Constant,
+        ast.And, ast.Or, ast.Not, ast.Eq, ast.NotEq, ast.Gt, ast.Lt,
+        ast.GtE, ast.LtE
+    }
+
+    def __init__(self, context):
+        self.context = context
+
+    def eval(self, expr):
+        tree = ast.parse(expr, mode='eval')
+        return self.visit(tree.body)
+
+    def visit(self, node):
+        if type(node) not in self.ALLOWED:
+            raise ValueError(f"Unsupported node: {type(node).__name__}")
+        return super().visit(node)
+
+    def visit_Name(self, node):
+        if node.id not in self.context:
+            raise ValueError(f"Undefined variable: {node.id}")
+        return self.context[node.id]
+
+    def visit_Constant(self, node):
+        return node.value
+
+    def visit_BoolOp(self, node):
+        vals = [self.visit(v) for v in node.values]
+        if isinstance(node.op, ast.And):
+            return all(vals)
+        elif isinstance(node.op, ast.Or):
+            return any(vals)
+        else:
+            raise ValueError("Unsupported BoolOp")
+
+    def visit_Compare(self, node):
+        left = self.visit(node.left)
+        for op, comp in zip(node.ops, node.comparators):
+            right = self.visit(comp)
+            if isinstance(op, ast.Eq) and not left == right:
+                return False
+            elif isinstance(op, ast.NotEq) and not left != right:
+                return False
+            elif isinstance(op, ast.Gt) and not left > right:
+                return False
+            elif isinstance(op, ast.Lt) and not left < right:
+                return False
+            elif isinstance(op, ast.GtE) and not left >= right:
+                return False
+            elif isinstance(op, ast.LtE) and not left <= right:
+                return False
+            else:
+                raise ValueError("Unsupported comparison operator")
+        return True
+
+    def visit_UnaryOp(self, node):
+        operand = self.visit(node.operand)
+        if isinstance(node.op, ast.Not):
+            return not operand
+        else:
+            raise ValueError("Unsupported unary operation")
+
+
+# action_registry.py
+import ast
+
+class ActionRegistry:
+    def __init__(self):
+        self._actions = {}
+
+    def register(self, name, func):
+        self._actions[name] = func
+
+    def execute(self, expr: str, context: dict):
+        tree = ast.parse(expr, mode='eval')
+        call = tree.body
+
+        if not isinstance(call, ast.Call):
+            raise ValueError("Action は関数呼び出し形式である必要があります")
+
+        if not isinstance(call.func, ast.Name):
+            raise ValueError("関数名が不正です")
+
+        func_name = call.func.id
+        if func_name not in self._actions:
+            raise ValueError(f"許可されていないアクション: {func_name}")
+
+        args = []
+        for arg in call.args:
+            if isinstance(arg, ast.Name):
+                if arg.id not in context:
+                    raise ValueError(f"アクションの引数変数が未定義: {arg.id}")
+                args.append(context[arg.id])
+            elif isinstance(arg, ast.Constant):
+                args.append(arg.value)
+            else:
+                raise ValueError("アクションの引数が不正です")
+
+        return self._actions[func_name](*args)
+
+
+# engine.py
+from .evaluator import SafeEvaluator
+from .parser import parse_rule_file
+from .action_registry import ActionRegistry
+
+class RuleEngine:
+    def __init__(self, rule_path, action_registry=None):
+        self.rules = parse_rule_file(rule_path)
+        self.registry = action_registry or ActionRegistry()
+
+    def resolve_rule(self, rule_name, visited=None):
+        visited = visited or set()
+        if rule_name in visited:
+            raise ValueError(f"循環 extends 検出: {rule_name}")
+        visited.add(rule_name)
+
+        rule = self.rules.get(rule_name)
+        if not rule:
+            raise ValueError(f"ルールが見つかりません: {rule_name}")
+
+        if rule.get("extends"):
+            parent = self.resolve_rule(rule["extends"], visited)
+            # 親ルールの内容をコピーしつつ、子ルールの値で上書き
+            combined = dict(parent)
+            combined.update(rule)
+            return combined
+
+        return rule
+
+    def check(self, rule_name, context):
+        try:
+            rule = self.resolve_rule(rule_name)
+        except Exception as e:
+            return False, f"継承エラー: {e}"
+
+        if not rule.get("enabled", True):
+            return False, "ルールは無効化されています"
+
+        expr = rule.get("when")
+        reason = rule.get("reason", "アクセス拒否")
+
+        try:
+            evaluator = SafeEvaluator(context)
+            result = evaluator.eval(expr)
+            if result:
+                action_expr = rule.get("action")
+                if action_expr:
+                    self.registry.execute(action_expr, context)
+                return True, None
+            else:
+                return False, reason
+        except Exception as e:
+            return False, f"評価エラー: {e}"

rulea/stdlib.py

@@ -0,0 +1 @@
+⠀

rulea-1.0.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: rulea
+Version: 1.0.0
+Summary: Rule-based programmable language in Python
+Home-page: https://github.com/tanuki276/rulea
+Author: あなた
+Author-email: soln <you@example.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+==============================
+rulea - Syntax and Usage
+
+Overview:
+
+rulea is a rule-based language that clearly defines "who can do what."
+With Python-like syntax, access or operation conditions are written in external .rulea files,
+which can then be evaluated from within an application.
+
+Basic Rule File Structure:
+
+rule <rule_name>:  
+    when: <condition_expression>  
+    reason: "<reason if denied>"  
+  
+The when: section accepts both Python expressions and if statements.  
+  
+Multi-line conditions are supported.  
+  
+  
+Examples:  
+  
+rule edit:  
+    when: user == owner and status != "locked"  
+    reason: "Only the owner can edit unlocked items"  
+  
+rule delete:  
+    when:  
+        if role == "admin":  
+            True  
+        elif user == owner:  
+            status != "archived"  
+        else:  
+            False  
+    reason: "Only admins or the owner (if not archived) can delete"  
+  
+Parameters are passed in externally as a context and are evaluated as variables.  
+  
+  
+Using in Python:  
+  
+from rulea import RuleEngine  
+  
+engine = RuleEngine("access.rulea")  
+ok, reason = engine.check("edit", {  
+    "user": "alice",  
+    "owner": "alice",  
+    "status": "active"  
+})  
+  
+if ok:  
+    print("Allowed")  
+else:  
+    print("Denied:", reason)  
+  
+Using in CLI:  
+  
+rulea access.rulea edit \  
+  --context '{"user": "alice", "owner": "bob", "status": "locked"}'  
+  
+Exit Codes:  
+  
+0 = Rule passed (allowed)  
+  
+1 = Rule failed (denied)  
+  
+  
+Notes:  
+  
+when: supports expressions and if statements  
+  
+reason: is returned when the rule is denied  
+  
+Conditions are evaluated in a safe Python environment  
+  
+.rulea files must be saved in UTF-8 encoding
+

rulea-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+rulea/__init__.py,sha256=2bpD61hCYDZ2NmFdTYTgvhtmesAGNVFJS3t2mNy5AhI,67
+rulea/cli.py,sha256=OFuPIHENxlDkWF8H_dV32MKySaJdOnI7-3Pu2-pAKoc,800
+rulea/engine.py,sha256=ALQsOOH1bGiDH-DqAfGyk_FaofOnVF0XfZrDfh3wWk8,642
+rulea/evaluator.py,sha256=dw8HPJbBjETrGeFFxzx5TvZvkWav2IwrRzw0fSvMhMQ,1689
+rulea/model.py,sha256=yKRYuT8mvl17xkYXxSphbTZ8pyDmJrFLYzuoTtN48XU,3
+rulea/parser.py,sha256=7BWLmtZslAETlvRXjg3XoDvIdDv3zJ6jF9PFsG4F8Kw,7609
+rulea/stdlib.py,sha256=yKRYuT8mvl17xkYXxSphbTZ8pyDmJrFLYzuoTtN48XU,3
+rulea-1.0.0.dist-info/licenses/LICENSE,sha256=eRpi5QuAFrW1F-5_o6_1T7N90JE06bG5buvX_tkGKGc,557
+rulea-1.0.0.dist-info/METADATA,sha256=yTTzx1gszTl--1Mhnd3K8MlYGsXnHwcu76XShDVGsmY,2176
+rulea-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rulea-1.0.0.dist-info/entry_points.txt,sha256=X-ZhiQZ6jVigZxcCnlcBx7ZVZ7IaCN8H8jFV3Cv6F6I,41
+rulea-1.0.0.dist-info/top_level.txt,sha256=MnAKoQOQHinSsfvOEx0_HSW60u1z4SxAtdQPc7CvIhU,6
+rulea-1.0.0.dist-info/RECORD,,

rulea-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rulea-1.0.0.dist-info/entry_points.txt

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

rulea-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2025 soln
+
+All rights reserved.
+
+---
+
+Unauthorized copying, reproduction, distribution, or use of this software and all associated code (hereinafter "the Software") is strictly prohibited.
+
+Use of the Software is only permitted with explicit prior written permission from the copyright holder.
+
+The copyright holder reserves the right to take legal action against any unauthorized use, reproduction, or distribution of the Software.
+
+---
+
+The Software is provided "as is," without any express or implied warranty.
+
+---
+
+[Contact Information]  

rulea-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+rulea