ice-rules 2.0.1__tar.gz

ice_rules-2.0.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: ice-rules
+Version: 2.0.1
+Summary: Ice Rule Engine Python SDK
+Author: waitmoon
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/waitmoon/ice
+Project-URL: Documentation, https://waitmoon.github.io/ice
+Project-URL: Repository, https://github.com/waitmoon/ice
+Keywords: ice,rule-engine,decision-engine
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Ice Python SDK
+
+Ice 规则引擎的 Python 实现，与 Java ice-core 和 Go SDK 功能一致。
+
+## 安装
+
+```bash
+pip install ice-rules
+```
+
+## 快速开始
+
+### 1. 注册叶子节点
+
+```python
+import ice
+from ice import Roam
+
+@ice.leaf("com.example.ScoreFlow")
+class ScoreFlow:
+    threshold: int = 0
+    
+    def do_roam_flow(self, roam: Roam) -> bool:
+        return roam.get_int("score", 0) >= self.threshold
+```
+
+### 2. 启动客户端
+
+```python
+# 同步方式
+client = ice.FileClient(app=1, storage_path="./ice-data")
+client.start()
+
+pack = ice.Pack(ice_id=1)
+pack.roam.put("score", 85)
+results = ice.sync_process(pack)
+
+client.destroy()
+```
+
+### 3. 异步方式
+
+```python
+import asyncio
+
+async def main():
+    client = ice.AsyncFileClient(app=1, storage_path="./ice-data")
+    await client.start()
+    
+    pack = ice.Pack(ice_id=1)
+    pack.roam.put("score", 85)
+    results = await ice.async_process(pack)
+    
+    await client.destroy()
+
+asyncio.run(main())
+```
+
+## 叶子节点类型
+
+### Flow 类型（返回 True/False）
+- `do_flow(ctx: Context) -> bool`
+- `do_pack_flow(pack: Pack) -> bool`
+- `do_roam_flow(roam: Roam) -> bool`
+
+### Result 类型（返回 True/False）
+- `do_result(ctx: Context) -> bool`
+- `do_pack_result(pack: Pack) -> bool`
+- `do_roam_result(roam: Roam) -> bool`
+
+### None 类型（无返回值）
+- `do_none(ctx: Context) -> None`
+- `do_pack_none(pack: Pack) -> None`
+- `do_roam_none(roam: Roam) -> None`
+
+## 版本要求
+
+- Python >= 3.11
+
+## License
+
+Apache-2.0
+

ice_rules-2.0.1/README.md

@@ -0,0 +1,83 @@
+# Ice Python SDK
+
+Ice 规则引擎的 Python 实现，与 Java ice-core 和 Go SDK 功能一致。
+
+## 安装
+
+```bash
+pip install ice-rules
+```
+
+## 快速开始
+
+### 1. 注册叶子节点
+
+```python
+import ice
+from ice import Roam
+
+@ice.leaf("com.example.ScoreFlow")
+class ScoreFlow:
+    threshold: int = 0
+    
+    def do_roam_flow(self, roam: Roam) -> bool:
+        return roam.get_int("score", 0) >= self.threshold
+```
+
+### 2. 启动客户端
+
+```python
+# 同步方式
+client = ice.FileClient(app=1, storage_path="./ice-data")
+client.start()
+
+pack = ice.Pack(ice_id=1)
+pack.roam.put("score", 85)
+results = ice.sync_process(pack)
+
+client.destroy()
+```
+
+### 3. 异步方式
+
+```python
+import asyncio
+
+async def main():
+    client = ice.AsyncFileClient(app=1, storage_path="./ice-data")
+    await client.start()
+    
+    pack = ice.Pack(ice_id=1)
+    pack.roam.put("score", 85)
+    results = await ice.async_process(pack)
+    
+    await client.destroy()
+
+asyncio.run(main())
+```
+
+## 叶子节点类型
+
+### Flow 类型（返回 True/False）
+- `do_flow(ctx: Context) -> bool`
+- `do_pack_flow(pack: Pack) -> bool`
+- `do_roam_flow(roam: Roam) -> bool`
+
+### Result 类型（返回 True/False）
+- `do_result(ctx: Context) -> bool`
+- `do_pack_result(pack: Pack) -> bool`
+- `do_roam_result(roam: Roam) -> bool`
+
+### None 类型（无返回值）
+- `do_none(ctx: Context) -> None`
+- `do_pack_none(pack: Pack) -> None`
+- `do_roam_none(roam: Roam) -> None`
+
+## 版本要求
+
+- Python >= 3.11
+
+## License
+
+Apache-2.0
+

ice_rules-2.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0", "setuptools_scm>=8.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ice-rules"
+dynamic = ["version"]
+description = "Ice Rule Engine Python SDK"
+readme = "README.md"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.11"
+authors = [
+    {name = "waitmoon"}
+]
+keywords = ["ice", "rule-engine", "decision-engine"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://github.com/waitmoon/ice"
+Documentation = "https://waitmoon.github.io/ice"
+Repository = "https://github.com/waitmoon/ice"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools_scm]
+root = "../../.."

ice_rules-2.0.1/setup.cfg

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

ice_rules-2.0.1/src/ice/__init__.py

@@ -0,0 +1,66 @@
+"""
+Ice Rule Engine Python SDK
+
+A Python implementation of the Ice rule engine, compatible with Java and Go SDKs.
+"""
+
+from ice.context.roam import Roam
+from ice.context.pack import Pack
+from ice.context.context import Context
+from ice.enums import RunState, NodeType, TimeType
+from ice.leaf.registry import leaf, register_leaf, get_leaf_nodes, LeafMeta, IceField, IceIgnore, FieldMeta
+from ice.log import Logger, set_logger
+from ice.client.file_client import FileClient
+from ice.client.async_file_client import AsyncFileClient
+from ice.dispatcher import (
+    sync_process,
+    async_process,
+    process_ctx,
+    process_single_ctx,
+    process_roam,
+    process_single_roam,
+    get_handler_by_id,
+    get_handlers_by_scene,
+)
+
+try:
+    from importlib.metadata import version
+    __version__ = version("ice-rules")
+except Exception:
+    __version__ = "0.0.0"  # fallback for development
+
+__all__ = [
+    # Context
+    "Roam",
+    "Pack",
+    "Context",
+    # Enums
+    "RunState",
+    "NodeType",
+    "TimeType",
+    # Leaf registration
+    "leaf",
+    "register_leaf",
+    "get_leaf_nodes",
+    "IceField",
+    "IceIgnore",
+    "LeafMeta",
+    # Logging
+    "Logger",
+    "set_logger",
+    # Clients
+    "FileClient",
+    "AsyncFileClient",
+    # Processing (main)
+    "sync_process",
+    "async_process",
+    # Processing (convenience - matching Java/Go)
+    "process_ctx",
+    "process_single_ctx",
+    "process_roam",
+    "process_single_roam",
+    # Handler access (matching Go)
+    "get_handler_by_id",
+    "get_handlers_by_scene",
+]
+

ice_rules-2.0.1/src/ice/_internal/__init__.py

@@ -0,0 +1,2 @@
+"""Internal utilities for Ice SDK."""
+

ice_rules-2.0.1/src/ice/_internal/executor.py

@@ -0,0 +1,82 @@
+"""Thread pool executor for parallel nodes in Ice SDK."""
+
+from __future__ import annotations
+
+import os
+from concurrent.futures import ThreadPoolExecutor, Future
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ice.context.context import Context
+    from ice.node.base import Node
+    from ice.enums import RunState
+
+
+# Global executor
+_executor: ThreadPoolExecutor | None = None
+
+
+def init_executor(parallelism: int = -1) -> None:
+    """
+    Initialize the global thread pool executor.
+    
+    Args:
+        parallelism: Number of worker threads. -1 means use CPU count.
+    """
+    global _executor
+    if _executor is not None:
+        return
+    
+    if parallelism <= 0:
+        parallelism = os.cpu_count() or 4
+    
+    _executor = ThreadPoolExecutor(max_workers=parallelism, thread_name_prefix="ice-worker")
+
+
+def shutdown_executor() -> None:
+    """Shutdown the global executor."""
+    global _executor
+    if _executor is not None:
+        _executor.shutdown(wait=True)
+        _executor = None
+
+
+def get_executor() -> ThreadPoolExecutor:
+    """Get the global executor, initializing if needed."""
+    global _executor
+    if _executor is None:
+        init_executor()
+    return _executor  # type: ignore
+
+
+@dataclass
+class NodeResult:
+    """Result of a node execution."""
+    state: RunState
+    error: Exception | None = None
+
+
+def submit_node(node: Node, ctx: Context) -> Future[NodeResult]:
+    """
+    Submit a node for execution in the thread pool.
+    
+    Args:
+        node: The node to execute
+        ctx: The execution context (should be a copy for parallel execution)
+    
+    Returns:
+        A Future containing the NodeResult
+    """
+    from ice.enums import RunState
+    
+    def execute() -> NodeResult:
+        try:
+            state = node.process(ctx)
+            return NodeResult(state=state)
+        except Exception as e:
+            return NodeResult(state=RunState.SHUT_DOWN, error=e)
+    
+    executor = get_executor()
+    return executor.submit(execute)
+

ice_rules-2.0.1/src/ice/_internal/timeutil.py

@@ -0,0 +1,51 @@
+"""Time utilities for Ice SDK."""
+
+from ice.enums import TimeType
+
+
+def time_disabled(
+    time_type: TimeType | int,
+    request_time: int,
+    start: int,
+    end: int,
+) -> bool:
+    """
+    Check if the node should be disabled based on time constraints.
+    
+    Args:
+        time_type: Time control type
+        request_time: Current request time in milliseconds
+        start: Start time in milliseconds
+        end: End time in milliseconds
+    
+    Returns:
+        True if the node should be disabled, False otherwise
+    """
+    if isinstance(time_type, int):
+        time_type = TimeType(time_type) if time_type in TimeType._value2member_map_ else TimeType.NONE
+    
+    if time_type == TimeType.NONE:
+        return False
+    
+    if time_type == TimeType.BETWEEN:
+        # Must be between start and end
+        if start > 0 and request_time < start:
+            return True
+        if end > 0 and request_time > end:
+            return True
+        return False
+    
+    if time_type == TimeType.AFTER_START:
+        # Must be after start
+        if start > 0 and request_time < start:
+            return True
+        return False
+    
+    if time_type == TimeType.BEFORE_END:
+        # Must be before end
+        if end > 0 and request_time > end:
+            return True
+        return False
+    
+    return False
+

ice_rules-2.0.1/src/ice/_internal/uuid.py

@@ -0,0 +1,80 @@
+"""UUID utilities for Ice SDK."""
+
+import base64
+import secrets
+import uuid as uuid_module
+
+# 64 character alphabet (same as Java: A-Z, a-z, 0-9, -, _)
+_DIGITS64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+
+
+def generate_uuid22() -> str:
+    """Generate a 22-character UUID (base64 encoded UUID without padding)."""
+    u = uuid_module.uuid4()
+    return base64.urlsafe_b64encode(u.bytes).decode("ascii").rstrip("=")
+
+
+def generate_uuid() -> str:
+    """Generate a standard UUID string."""
+    return str(uuid_module.uuid4())
+
+
+def generate_short_id() -> str:
+    """
+    Generate an 11-character short ID (same format as Java).
+    Uses 8 random bytes encoded with base64 variant to produce 11 characters.
+    """
+    random_bytes = bytearray(secrets.token_bytes(8))
+    
+    # Set version 4 marker (same as Java)
+    random_bytes[6] = (random_bytes[6] & 0x0f) | 0x40
+    
+    # Convert bytes to int64
+    msb = 0
+    for i in range(8):
+        msb = (msb << 8) | (random_bytes[i] & 0xff)
+    
+    # Encode to 11 characters using base64 variant
+    out = [''] * 12
+    bit = 0
+    bt1 = 8
+    bt2 = 8
+    offsetm = 1
+    idx = 0
+    
+    while offsetm > 0:
+        offsetm = 64 - ((bit + 3) << 3)
+        
+        if bt1 > 3:
+            mask = (1 << (8 * 3)) - 1
+        elif bt1 >= 0:
+            mask = (1 << (8 * bt1)) - 1
+            bt2 -= 3 - bt1
+        else:
+            min_bt = min(bt2, 3)
+            mask = (1 << (8 * min_bt)) - 1
+            bt2 -= 3
+        
+        tmp = 0
+        if bt1 > 0:
+            bt1 -= 3
+            if offsetm < 0:
+                tmp = msb
+            else:
+                tmp = (msb >> offsetm) & mask
+            if bt1 < 0:
+                tmp <<= abs(offsetm)
+        
+        out[idx + 3] = _DIGITS64[tmp & 0x3f]
+        tmp >>= 6
+        out[idx + 2] = _DIGITS64[tmp & 0x3f]
+        tmp >>= 6
+        out[idx + 1] = _DIGITS64[tmp & 0x3f]
+        tmp >>= 6
+        out[idx] = _DIGITS64[tmp & 0x3f]
+        
+        bit += 3
+        idx += 4
+    
+    return ''.join(out[:11])
+

ice_rules-2.0.1/src/ice/cache/__init__.py

@@ -0,0 +1,6 @@
+"""Cache module for Ice SDK."""
+
+from ice.cache import conf_cache
+from ice.cache import handler_cache
+
+__all__ = ["conf_cache", "handler_cache"]