deepfos 1.1.60__py3-none-any.whl

deepfos/lib/serutils.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import datetime
+import decimal
+import functools
+import uuid
+from dataclasses import dataclass
+from typing import Any
+
+import edgedb
+from edgedb.introspect import introspect_object as intro
+from edgedb.datatypes import datatypes
+
+
+@dataclass(frozen=True)
+class Context:
+    frame_desc: Any = None
+    query_df: bool = False
+
+
+@functools.singledispatch
+def serialize(o, ctx: Context = Context()):
+    raise TypeError(f'无法序列化类型: {type(o)}')
+
+
+@functools.singledispatch
+def deserialize(o):
+    raise TypeError(f'无法反序列化类型: {type(o)}')
+
+
+@deserialize.register
+def to_object(o: dict):
+    _id = o.pop('id', None)
+    ordered_attr = o.keys()
+    obj_cls = datatypes.create_object_factory(
+        id='property' if _id else 'implicit',
+        **{k: 'link' if isinstance(o[k], dict) else 'property' for k in ordered_attr}
+    )
+    actual_id = None
+    if _id:
+        if isinstance(_id, str):
+            actual_id = uuid.UUID(_id)
+        elif isinstance(_id, uuid.UUID):
+            actual_id = _id
+    return obj_cls(
+        actual_id,
+        *[deserialize(o[k]) for k in ordered_attr]
+    )
+
+
+@deserialize.register
+def to_set(o: list):
+    return [deserialize(ele) for ele in o]
+
+
+@deserialize.register
+def to_tuple(o: tuple):
+    return tuple(deserialize(ele) for ele in o)
+
+
+@deserialize.register(int)
+@deserialize.register(float)
+@deserialize.register(str)
+@deserialize.register(bytes)
+@deserialize.register(bool)
+@deserialize.register(type(None))
+@deserialize.register(datetime.datetime)
+def to_scalar(o):
+    return o
+
+
+@serialize.register
+def _tuple(o: edgedb.Tuple, ctx: Context = Context()):
+    if ctx.frame_desc is None:
+        return tuple(serialize(el) for el in o)
+    return tuple(
+        serialize(el, Context(frame_desc=ctx.frame_desc[idx])) 
+        for idx, el in enumerate(o)
+    )
+
+
+@serialize.register
+def _namedtuple(o: edgedb.NamedTuple, ctx: Context = Context()):
+    if ctx.frame_desc is None:
+        return {attr: serialize(getattr(o, attr)) for attr in dir(o)}
+    return {
+        attr: serialize(getattr(o, attr), Context(frame_desc=ctx.frame_desc[attr]))
+        for attr in ctx.frame_desc
+    }
+
+
+@serialize.register
+def _linkset(o: edgedb.LinkSet, ctx: Context = Context()):
+    return [serialize(el, ctx) for el in o]
+
+
+@serialize.register
+def _link(o: edgedb.Link, ctx: Context = Context()):
+    ret = {}
+    if ctx.frame_desc is None:
+        for lprop in dir(o):
+            if lprop in {'source', 'target'}:
+                continue
+            ret[f'@{lprop}'] = serialize(getattr(o, lprop))
+
+        ret.update(_object(o.target))
+        return ret
+
+    lprops = list(map(lambda x: f'@{x}', (set(dir(o)) - {'source', 'target'})))
+    for field in ctx.frame_desc:
+        new_ctx = Context(frame_desc=ctx.frame_desc[field])
+        if field in lprops:
+            ret[field] = serialize(getattr(o, field[1:]), new_ctx)
+        else:
+            ret[field] = serialize(getattr(o.target, field), new_ctx)
+    return ret
+
+
+def ignore_implicited_fields(o: edgedb.Object):
+    return set(dir(o)) - {desc.name for desc in intro(o).pointers if desc.implicit}
+
+
+@serialize.register
+def _object(o: edgedb.Object, ctx: Context = Context()):
+    ret = {}
+
+    if ctx.frame_desc is None:
+        if ctx.query_df:
+            attrs = dir(o)
+        else:
+            attrs = ignore_implicited_fields(o)
+        for attr in attrs:
+            try:
+                ret[attr] = serialize(o[attr])
+            except (KeyError, TypeError):
+                ret[attr] = serialize(getattr(o, attr))
+        return ret
+
+    ensure_one_field = ctx.query_df and len(ctx.frame_desc) == 1
+    for key, value in dict(ctx.frame_desc).items():
+        if isinstance(key, tuple):
+            # key: (field_name, not_implicit)
+            maybe_drop = ctx.frame_desc.pop(key)
+            if ensure_one_field or key[1]:
+                ctx.frame_desc[key[0]] = maybe_drop
+
+    for attr in ctx.frame_desc:
+        try:
+            ret[attr] = serialize(o[attr], Context(frame_desc=ctx.frame_desc[attr]))
+        except (KeyError, TypeError):
+            ret[attr] = serialize(getattr(o, attr), Context(frame_desc=ctx.frame_desc[attr]))
+
+    return ret
+
+
+@serialize.register(edgedb.Set)
+@serialize.register(edgedb.Array)
+def _set(o, ctx: Context = Context()):
+    return [serialize(el, ctx) for el in o]
+
+
+@serialize.register(int)
+@serialize.register(float)
+@serialize.register(str)
+@serialize.register(bytes)
+@serialize.register(bool)
+@serialize.register(type(None))
+@serialize.register(datetime.timedelta)
+@serialize.register(datetime.date)
+@serialize.register(datetime.datetime)
+@serialize.register(datetime.time)
+@serialize.register(edgedb.RelativeDuration)
+@serialize.register(uuid.UUID)
+@serialize.register(decimal.Decimal)
+def _scalar(o, ctx: Context = Context()):
+    return o
+
+
+@serialize.register
+def _enum(o: edgedb.EnumValue, ctx: Context = Context()):
+    return str(o)

deepfos/lib/stopwatch.py

@@ -0,0 +1,99 @@
+"""计时器"""
+
+import functools
+import time
+from collections import OrderedDict
+from deepfos.lib.utils import CIEnum
+from loguru import logger
+
+
+class TimeUnit(CIEnum):
+    ns = 'ns'
+    us = 'us'
+    ms = 'ms'
+    s = 's'
+    m = 'm'
+    h = 'h'
+
+
+TIME_MAP = {
+    'ns': 1,
+    'us': 1_000,
+    'ms': 1_000_000,
+    's': 1_000_000_000,
+    'm': 60_000_000_000,
+    'h': 3_600_000_000_000,
+}
+
+
+class Stopwatch(object):
+    """计时器
+
+    Args:
+        unit: 计时单位
+        sink: 耗时信息的输出函数，默认为 ``logger.info``
+
+    >>> watch = Stopwatch(unit='s', sink=print)
+    >>> import time
+    >>> with watch('[task - sleep]'):
+    ...    time.sleep(0)
+    [task - sleep]:0.00s
+    """
+    __slots__ = (
+        'runtimes', 'start_stack', 'rec_count', 'name',
+        '_unit_repr', '_unit', '_sink'
+    )
+
+    def __init__(self, unit: str = 'ns', sink=logger.info):
+        self.runtimes = OrderedDict()
+        self.start_stack = []
+        self.rec_count = 0
+        self.name = []
+        self._unit_repr = _unit = TimeUnit[unit]
+        self._unit = TIME_MAP[_unit]
+        self._sink = sink
+
+    def __call__(self, name=None):
+        self.name.append(name)
+        return self
+
+    def __enter__(self):
+        self.rec_count += 1
+        self.start_stack.append(time.perf_counter_ns())
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        time_gap = time.perf_counter_ns() - self.start_stack.pop(-1)
+        if self.name and self.name[-1] is not None:
+            key = self.name.pop(-1)
+        else:
+            key = f"task{self.rec_count}"
+        self._sink(f"{key}:{time_gap / self._unit :.2f}{self._unit_repr}")
+        self.runtimes[key] = time_gap
+
+    def get_all_runtime(self):
+        return list(self.runtimes.values())
+
+    def clear(self):
+        self.runtimes.clear()
+        self.rec_count = 0
+
+    def __repr__(self):
+        return ', '.join(
+            f"{name}:{t / self._unit :.2f}{self._unit_repr}"
+            for name, t in self.runtimes.items()
+        )
+
+
+def stopwatch(func=None, unit: str = 's'):  # pragma: no cover
+    if func is None:
+        return functools.partial(stopwatch, unit=unit)
+
+    watch = Stopwatch(unit)
+
+    @functools.wraps(func)
+    def wrap(*args, **kwargs):
+        with watch(func.__qualname__):
+            rtn = func(*args, **kwargs)
+
+        return rtn
+    return wrap