vools 0.2.1__tar.gz → 0.2.2__tar.gz

{vools-0.2.1/vools.egg-info → vools-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vools
-Version: 0.2.1
+Version: 0.2.2
 Summary: Python 函数式编程工具集
 Author-email: Victor <victortop921129@gmail.com>
 License: Apache License

{vools-0.2.1 → vools-0.2.2}/vools/__init__.py

@@ -7,7 +7,7 @@ vools - Python 函数式编程工具集
 import importlib
 from typing import Any
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 __author__ = "Victor"
 __license__ = "Apache 2.0"
 

{vools-0.2.1 → vools-0.2.2}/vools/bridge/_base.py

@@ -1,4 +1,4 @@
-"""
+"""
 vools.bridge._base - 跨语言桥接抽象接口 (Lang Bridge)
 
 定义统一的 Lang 接口规范，所有语言桥接模块必须实现此接口。
@@ -59,7 +59,7 @@ from typing import (
     get_type_hints,
 )
 from vools.core.dataclass_compat import dataclass, field
-from vools.utils.asyncio_compat import run as asyncio_run
+from vools.core.asyncio_compat import run as asyncio_run
 
 
 # ============================================================================

{vools-0.2.1 → vools-0.2.2}/vools/bridge/core/sigcache.py

@@ -19,6 +19,7 @@ vools.bridge.core.sigcache - Bridge 子包签名缓存机制
 
 import inspect
 import logging
+import weakref
 from collections import OrderedDict
 from typing import Any, Callable, Dict, Optional, List
 
@@ -32,6 +33,7 @@ class BridgeSigCache:
     """Bridge 签名缓存类，每种语言桥接可以有自己的缓存实例。
 
     使用 OrderedDict 实现 LRU 淘汰策略，按语言命名空间隔离缓存。
+    使用 weakref 跟踪函数对象生命周期，避免 id 复用导致的缓存错误命中。
 
     Attributes:
         lang: 语言名称，用于标识缓存命名空间。
@@ -51,9 +53,61 @@ class BridgeSigCache:
         self._annotations_cache: OrderedDict = OrderedDict()
         self._body_cache: OrderedDict = OrderedDict()
         self._spec_cache: OrderedDict = OrderedDict()
+        self._weak_refs: Dict[int, weakref.ref] = {}
         self._hits = 0
         self._misses = 0
 
+    def _on_object_dead(self, ref: weakref.ref) -> None:
+        """弱引用回调：当被引用的函数对象被回收时，清理对应缓存。
+
+        Args:
+            ref: 已失效的弱引用对象。
+        """
+        dead_id = None
+        for obj_id, r in list(self._weak_refs.items()):
+            if r is ref:
+                dead_id = obj_id
+                break
+        if dead_id is not None:
+            self._weak_refs.pop(dead_id, None)
+            self._sig_cache.pop(dead_id, None)
+            self._annotations_cache.pop(dead_id, None)
+            for key in list(self._body_cache.keys()):
+                if isinstance(key, tuple) and key[0] == dead_id:
+                    self._body_cache.pop(key, None)
+            for key in list(self._spec_cache.keys()):
+                if isinstance(key, tuple) and key[0] == dead_id:
+                    self._spec_cache.pop(key, None)
+
+    def _register_weakref(self, func: Callable) -> None:
+        """注册函数对象的弱引用，用于检测对象回收。
+
+        Args:
+            func: 要跟踪的函数对象。
+        """
+        obj_id = id(func)
+        if obj_id not in self._weak_refs:
+            try:
+                ref = weakref.ref(func, self._on_object_dead)
+                self._weak_refs[obj_id] = ref
+            except TypeError:
+                pass
+
+    def _is_valid(self, func: Callable, obj_id: int) -> bool:
+        """检查缓存键对应的对象是否仍然有效。
+
+        Args:
+            func: 当前函数对象（用于验证）。
+            obj_id: 缓存键（id）。
+
+        Returns:
+            True 如果缓存有效，False 如果已失效。
+        """
+        if obj_id not in self._weak_refs:
+            return False
+        ref = self._weak_refs[obj_id]
+        return ref() is func
+
     def _cache_get(self, cache: OrderedDict, key: int) -> Any:
         """从 OrderedDict 缓存中获取值并更新 LRU 顺序。
 
@@ -100,13 +154,13 @@ class BridgeSigCache:
             inspect.Signature 对象。
         """
         key = id(func)
-        try:
+        if key in self._sig_cache and self._is_valid(func, key):
             return self._cache_get(self._sig_cache, key)
-        except KeyError:
-            self._misses += 1
-            sig = inspect.signature(func)
-            self._cache_set(self._sig_cache, key, sig)
-            return sig
+        self._misses += 1
+        self._register_weakref(func)
+        sig = inspect.signature(func)
+        self._cache_set(self._sig_cache, key, sig)
+        return sig
 
     def has_signature(self, func: Callable[..., Any]) -> bool:
         """检查函数签名是否已缓存。
@@ -117,7 +171,8 @@ class BridgeSigCache:
         Returns:
             True 如果已缓存，否则 False。
         """
-        return id(func) in self._sig_cache
+        key = id(func)
+        return key in self._sig_cache and self._is_valid(func, key)
 
     # ------------------------------------------------------------------
     # 类型注解缓存
@@ -137,16 +192,16 @@ class BridgeSigCache:
         from typing import get_type_hints
 
         key = id(func)
-        try:
+        if key in self._annotations_cache and self._is_valid(func, key):
             return self._cache_get(self._annotations_cache, key)
-        except KeyError:
-            self._misses += 1
-            try:
-                annotations = get_type_hints(func)
-            except Exception:
-                annotations = getattr(func, '__annotations__', {}) or {}
-            self._cache_set(self._annotations_cache, key, annotations)
-            return annotations
+        self._misses += 1
+        self._register_weakref(func)
+        try:
+            annotations = get_type_hints(func)
+        except Exception:
+            annotations = getattr(func, '__annotations__', {}) or {}
+        self._cache_set(self._annotations_cache, key, annotations)
+        return annotations
 
     def has_annotations(self, func: Callable[..., Any]) -> bool:
         """检查函数类型注解是否已缓存。
@@ -157,7 +212,8 @@ class BridgeSigCache:
         Returns:
             True 如果已缓存，否则 False。
         """
-        return id(func) in self._annotations_cache
+        key = id(func)
+        return key in self._annotations_cache and self._is_valid(func, key)
 
     # ------------------------------------------------------------------
     # 函数体缓存
@@ -182,13 +238,13 @@ class BridgeSigCache:
 
         cache_key = (id(func), _hash_args(args, kwargs))
 
-        try:
+        if cache_key in self._body_cache and self._is_valid(func, id(func)):
             return self._cache_get(self._body_cache, cache_key)
-        except KeyError:
-            self._misses += 1
-            body = _extract_body(func, args, kwargs)
-            self._cache_set(self._body_cache, cache_key, body)
-            return body
+        self._misses += 1
+        self._register_weakref(func)
+        body = _extract_body(func, args, kwargs)
+        self._cache_set(self._body_cache, cache_key, body)
+        return body
 
     def has_body(self, func: Callable[..., Any], args: tuple = (), kwargs: Optional[Dict[str, Any]] = None) -> bool:
         """检查函数体是否已缓存。
@@ -204,7 +260,7 @@ class BridgeSigCache:
         if kwargs is None:
             kwargs = {}
         cache_key = (id(func), _hash_args(args, kwargs))
-        return cache_key in self._body_cache
+        return cache_key in self._body_cache and self._is_valid(func, id(func))
 
     # ------------------------------------------------------------------
     # FunctionSpec 缓存
@@ -228,32 +284,32 @@ class BridgeSigCache:
 
         cache_key = (id(func), _hash_args(args, kwargs))
 
-        try:
+        if cache_key in self._spec_cache and self._is_valid(func, id(func)):
             return self._cache_get(self._spec_cache, cache_key)
-        except KeyError:
-            self._misses += 1
-            from .._base import FunctionSpec
-
-            name = func.__name__
-            annotations = self.get_annotations(func)
-            sig = self.get_signature(func)
-
-            defaults = {}
-            for param_name, param in sig.parameters.items():
-                if param.default is not inspect.Parameter.empty:
-                    defaults[param_name] = param.default
-
-            body = self.get_body(func, args, kwargs)
-
-            spec = FunctionSpec(
-                name=name,
-                annotations=annotations,
-                args=args,
-                defaults=defaults,
-                body=body,
-            )
-            self._cache_set(self._spec_cache, cache_key, spec)
-            return spec
+        self._misses += 1
+        self._register_weakref(func)
+        from .._base import FunctionSpec
+
+        name = func.__name__
+        annotations = self.get_annotations(func)
+        sig = self.get_signature(func)
+
+        defaults = {}
+        for param_name, param in sig.parameters.items():
+            if param.default is not inspect.Parameter.empty:
+                defaults[param_name] = param.default
+
+        body = self.get_body(func, args, kwargs)
+
+        spec = FunctionSpec(
+            name=name,
+            annotations=annotations,
+            args=args,
+            defaults=defaults,
+            body=body,
+        )
+        self._cache_set(self._spec_cache, cache_key, spec)
+        return spec
 
     def has_spec(self, func: Callable[..., Any], args: tuple = (), kwargs: Optional[Dict[str, Any]] = None) -> bool:
         """检查 FunctionSpec 是否已缓存。
@@ -269,7 +325,7 @@ class BridgeSigCache:
         if kwargs is None:
             kwargs = {}
         cache_key = (id(func), _hash_args(args, kwargs))
-        return cache_key in self._spec_cache
+        return cache_key in self._spec_cache and self._is_valid(func, id(func))
 
     # ------------------------------------------------------------------
     # 缓存管理

{vools-0.2.1 → vools-0.2.2}/vools/bridge/freebasic/transport.py

@@ -11,12 +11,17 @@ vools.bridge.freebasic.transport - 免序列化 Transport 抽象
 - 本模块让 list 直接以 POINTER(c_long) 形式传入，跳过 CSV 中转
 """
 
-from typing import Any, Tuple, Protocol
+from typing import Any, Tuple
 
 import ctypes
 
 from .types import FB_TO_CTYPES, is_array_type
 
+try:
+    from typing import Protocol
+except ImportError:
+    Protocol = object
+
 
 class Transport(object):
     """

{vools-0.2.1 → vools-0.2.2}/vools/bridge/manager.py

@@ -1,4 +1,4 @@
-"""
+"""
 vools.bridge.manager - 跨语言桥接统一管理器
 
 提供各种外部语言编译器和运行时环境的统一配置、管理和查询。
@@ -98,6 +98,8 @@ class LanguageConfig:
         elif _IS_MACOS and self.library_suffix == '':
             self.library_suffix = '.dylib'
 
+    __attrs_post_init__ = __post_init__
+
 
 @dataclass
 class LanguageStatus:

{vools-0.2.1 → vools-0.2.2}/vools/bridge/zig/compiler.py

@@ -17,7 +17,7 @@ import shutil
 from typing import Optional, Any, Dict, List
 
 from vools.bridge._base import LangBridge, FunctionSpec
-from vools.utils.asyncio_compat import run as asyncio_run
+from vools.core.asyncio_compat import run as asyncio_run
 from .types import PY_TO_ZIG_TYPE, ZIG_TO_CTYPES, get_zig_type, get_zig_ctype
 
 

vools-0.2.2/vools/core/asyncio_compat.py

@@ -0,0 +1,122 @@
+"""
+asyncio 兼容层 — 统一处理 Python 不同版本的 asyncio 接口
+
+在高版本 Python 使用标准库 asyncio 的原生接口，
+在低版本（<3.7）提供手动实现的兼容版本。
+
+提供与标准库一致的接口：
+- get_running_loop()           → 获取当前运行的事件循环
+- run(coro, *, debug=False)     → 运行协程并返回结果
+- create_task(coro, *, name=None) → 创建任务
+"""
+
+__all__ = ['get_running_loop', 'run', 'create_task']
+
+import asyncio
+import sys
+
+# ================================================================
+# 检测运行环境
+# ================================================================
+
+_HAS_GET_RUNNING_LOOP = sys.version_info >= (3, 7)
+_HAS_ASYNCIO_RUN = sys.version_info >= (3, 7)
+_HAS_CREATE_TASK = sys.version_info >= (3, 7)
+
+if _HAS_GET_RUNNING_LOOP and _HAS_ASYNCIO_RUN and _HAS_CREATE_TASK:
+    # ── 标准库 asyncio（3.7+） ──
+    get_running_loop = asyncio.get_running_loop
+    run = asyncio.run
+    create_task = asyncio.create_task
+
+else:
+    # ── Python 3.6 兼容实现 ──
+
+    def get_running_loop():
+        """
+        获取当前运行的事件循环。
+
+        Python 3.7+ 有 asyncio.get_running_loop()，
+        Python 3.6 使用 asyncio._get_running_loop() 作为替代。
+
+        Returns:
+            当前运行的事件循环。
+
+        Raises:
+            RuntimeError: 如果没有正在运行的事件循环。
+        """
+        loop = asyncio._get_running_loop()
+        if loop is None:
+            raise RuntimeError('no running event loop')
+        return loop
+
+    def run(coro, *, debug=False):
+        """
+        运行一个协程并返回结果。
+
+        Python 3.7+ 有 asyncio.run()，
+        Python 3.6 手动实现。
+
+        Args:
+            coro: 要运行的协程。
+            debug: 是否启用调试模式。
+
+        Returns:
+            协程的返回值。
+        """
+        loop = asyncio.new_event_loop()
+        try:
+            asyncio.set_event_loop(loop)
+            loop.set_debug(debug)
+            return loop.run_until_complete(coro)
+        finally:
+            try:
+                _cancel_all_tasks(loop)
+                if hasattr(loop, 'shutdown_asyncgens'):
+                    loop.run_until_complete(loop.shutdown_asyncgens())
+            finally:
+                asyncio.set_event_loop(None)
+                loop.close()
+
+    def create_task(coro, *, name=None):
+        """
+        创建一个任务。
+
+        Python 3.7+ 有 asyncio.create_task()，
+        Python 3.6 使用 asyncio.ensure_future() 作为替代。
+
+        Args:
+            coro: 协程对象。
+            name: 任务名称（3.6 忽略）。
+
+        Returns:
+            Task 对象。
+        """
+        return asyncio.ensure_future(coro)
+
+    def _cancel_all_tasks(loop):
+        """取消所有任务（Python 3.6 兼容）"""
+        if hasattr(asyncio, 'all_tasks'):
+            to_cancel = asyncio.all_tasks(loop)
+        else:
+            to_cancel = asyncio.Task.all_tasks(loop)
+
+        if not to_cancel:
+            return
+
+        for task in to_cancel:
+            task.cancel()
+
+        loop.run_until_complete(
+            asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)
+        )
+
+        for task in to_cancel:
+            if task.cancelled():
+                continue
+            if task.exception() is not None:
+                loop.call_exception_handler({
+                    'message': 'unhandled exception during asyncio.run() shutdown',
+                    'exception': task.exception(),
+                    'task': task,
+                })

{vools-0.2.1 → vools-0.2.2}/vools/core/dataclass_compat.py

@@ -11,7 +11,7 @@ dataclass 兼容层 — 统一处理 Python 不同版本的 dataclass 导入
 - is_dataclass(obj)         → 判断
 """
 
-__all__ = ['dataclass', 'field', 'asdict', 'is_dataclass', 'MISSING']
+__all__ = ['dataclass', 'field', 'asdict', 'is_dataclass', 'MISSING', 'FrozenInstanceError']
 
 from typing import Any, Dict, Callable, TypeVar, Optional
 import sys
@@ -31,6 +31,7 @@ if _HAS_DATACLASSES:
     from dataclasses import asdict as _std_asdict
     from dataclasses import is_dataclass as _std_is_dataclass
     from dataclasses import MISSING as _std_MISSING
+    from dataclasses import FrozenInstanceError as _std_FrozenInstanceError
 
     def dataclass(cls: Optional[_T] = None, **kwargs) -> _T:
         """dataclass 装饰器（标准库模式）"""
@@ -42,12 +43,14 @@ if _HAS_DATACLASSES:
     asdict = _std_asdict
     is_dataclass = _std_is_dataclass
     MISSING = _std_MISSING
+    FrozenInstanceError = _std_FrozenInstanceError
 
 else:
     # ── attrs 降级模式 ──
     try:
         from attr import attrs, attrib, asdict as _attr_asdict
         from attr import has as _attr_has
+        from attr.exceptions import FrozenInstanceError as _attr_FrozenInstanceError
     except ImportError:
         msg = (
             "Python < 3.7 detected but 'attrs' package is not installed. "
@@ -92,11 +95,19 @@ else:
         - order: bool      → 忽略（attrs 不支持自动排序）
         """
         frozen = kwargs.pop('frozen', False)
+
+        def _wrap(c):
+            wrapped = attrs(c, frozen=frozen, auto_attribs=True)
+            # 兼容 __post_init__: attrs 用 __attrs_post_init__
+            if hasattr(wrapped, '__post_init__') and not hasattr(wrapped, '__attrs_post_init__'):
+                wrapped.__attrs_post_init__ = wrapped.__post_init__
+            return wrapped
+
         # attrs 的 frozen 默认是 False，等价
         if cls is not None:
-            return attrs(cls, frozen=frozen, auto_attribs=True)
+            return _wrap(cls)
         # 带参装饰器模式: @dataclass(frozen=True)
-        return lambda c: attrs(c, frozen=frozen, auto_attribs=True)
+        return _wrap
 
     def field(*, default=MISSING, default_factory=MISSING, **kwargs) -> Any:
         """
@@ -123,3 +134,5 @@ else:
     def is_dataclass(obj) -> bool:
         """判断是否为 dataclass/attrs 实例"""
         return _attr_has(obj)
+
+    FrozenInstanceError = _attr_FrozenInstanceError

vools-0.2.2/vools/core/datetime_compat.py

@@ -0,0 +1,180 @@
+"""
+datetime 兼容层 — 统一处理 Python 不同版本的 datetime 接口
+
+在高版本 Python 使用标准库 datetime 的原生接口，
+在低版本（<3.7）提供兼容实现。
+
+提供的兼容接口：
+- datetime_fromisoformat(date_string)  → datetime.fromisoformat
+- date_fromisoformat(date_string)      → date.fromisoformat
+- time_fromisoformat(time_string)      → time.fromisoformat
+"""
+
+__all__ = [
+    'datetime_fromisoformat',
+    'date_fromisoformat',
+    'time_fromisoformat',
+]
+
+import sys
+import datetime
+
+_HAS_FROMISOFORMAT = sys.version_info >= (3, 7)
+
+
+if _HAS_FROMISOFORMAT:
+    # ── 标准库 datetime（3.7+） ──
+
+    def datetime_fromisoformat(date_string):
+        """Python 3.7+ 的 datetime.fromisoformat"""
+        return datetime.datetime.fromisoformat(date_string)
+
+    def date_fromisoformat(date_string):
+        """Python 3.7+ 的 date.fromisoformat"""
+        return datetime.date.fromisoformat(date_string)
+
+    def time_fromisoformat(time_string):
+        """Python 3.7+ 的 time.fromisoformat"""
+        return datetime.time.fromisoformat(time_string)
+
+else:
+    # ── Python 3.6 兼容实现 ──
+    # 使用 strptime 解析常见的 ISO 格式
+
+    import re
+
+    _DATETIME_RE = re.compile(
+        r'^(\d{4})-(\d{1,2})-(\d{1,2})'
+        r'[T ](\d{1,2}):(\d{1,2})(?::(\d{1,2})(?:\.(\d{1,6}))?)?'
+        r'(?:Z|[+-]\d{2}:?\d{2})?$'
+    )
+
+    _DATE_RE = re.compile(r'^(\d{4})-(\d{1,2})-(\d{1,2})$')
+
+    _TIME_RE = re.compile(
+        r'^(\d{1,2}):(\d{1,2})(?::(\d{1,2})(?:\.(\d{1,6}))?)?$'
+    )
+
+    def datetime_fromisoformat(date_string):
+        """
+        兼容版 datetime.fromisoformat（Python 3.6）。
+
+        支持常见的 ISO 8601 格式：
+        - YYYY-MM-DDTHH:MM:SS
+        - YYYY-MM-DD HH:MM:SS
+        - 带微秒、不带秒等变体
+
+        Args:
+            date_string: ISO 格式的日期时间字符串。
+
+        Returns:
+            datetime.datetime 对象。
+
+        Raises:
+            ValueError: 如果字符串格式不支持。
+        """
+        if isinstance(date_string, datetime.datetime):
+            return date_string
+
+        s = str(date_string).strip()
+
+        # 先尝试用 strptime 解析常见格式
+        formats = [
+            '%Y-%m-%dT%H:%M:%S.%f',
+            '%Y-%m-%d %H:%M:%S.%f',
+            '%Y-%m-%dT%H:%M:%S',
+            '%Y-%m-%d %H:%M:%S',
+            '%Y-%m-%dT%H:%M',
+            '%Y-%m-%d %H:%M',
+        ]
+        for fmt in formats:
+            try:
+                return datetime.datetime.strptime(s, fmt)
+            except ValueError:
+                continue
+
+        # 尝试用正则解析
+        m = _DATETIME_RE.match(s)
+        if m:
+            year, month, day = int(m.group(1)), int(m.group(2)), int(m.group(3))
+            hour, minute = int(m.group(4)), int(m.group(5))
+            second = int(m.group(6)) if m.group(6) else 0
+            microsecond = 0
+            if m.group(7):
+                micro_str = m.group(7).ljust(6, '0')
+                microsecond = int(micro_str)
+            return datetime.datetime(
+                year, month, day, hour, minute, second, microsecond
+            )
+
+        raise ValueError(
+            'Invalid isoformat string: %r' % date_string
+        )
+
+    def date_fromisoformat(date_string):
+        """
+        兼容版 date.fromisoformat（Python 3.6）。
+
+        Args:
+            date_string: ISO 格式的日期字符串。
+
+        Returns:
+            datetime.date 对象。
+        """
+        if isinstance(date_string, datetime.date):
+            return date_string
+
+        s = str(date_string).strip()
+
+        try:
+            return datetime.datetime.strptime(s, '%Y-%m-%d').date()
+        except ValueError:
+            pass
+
+        m = _DATE_RE.match(s)
+        if m:
+            return datetime.date(int(m.group(1)), int(m.group(2)), int(m.group(3)))
+
+        raise ValueError(
+            'Invalid isoformat string: %r' % date_string
+        )
+
+    def time_fromisoformat(time_string):
+        """
+        兼容版 time.fromisoformat（Python 3.6）。
+
+        Args:
+            time_string: ISO 格式的时间字符串。
+
+        Returns:
+            datetime.time 对象。
+        """
+        if isinstance(time_string, datetime.time):
+            return time_string
+
+        s = str(time_string).strip()
+
+        formats = [
+            '%H:%M:%S.%f',
+            '%H:%M:%S',
+            '%H:%M',
+        ]
+        for fmt in formats:
+            try:
+                return datetime.datetime.strptime(s, fmt).time()
+            except ValueError:
+                continue
+
+        m = _TIME_RE.match(s)
+        if m:
+            hour, minute = int(m.group(1)), int(m.group(2))
+            second = int(m.group(3)) if m.group(3) else 0
+            microsecond = 0
+            if m.group(4):
+                micro_str = m.group(4).ljust(6, '0')
+                microsecond = int(micro_str)
+            return datetime.time(hour, minute, second, microsecond)
+
+        raise ValueError(
+            'Invalid isoformat string: %r' % time_string
+        )