omlish 0.0.0.dev1__py3-none-any.whl

omlish/dynamic.py

@@ -0,0 +1,220 @@
+"""
+Dynamically scoped variables (implemented by stackwalking). Unlike threadlocals these are generator-correct both in
+binding and retrieval, and unlike ContextVars they require no manual context management. They are however *slow* and
+should be used sparingly (once per sql statement executed not once per inner function call).
+
+TODO:
+ - clj-style binding conveyance
+ - contextvar/async interop
+ - 'partializer'
+"""
+import contextlib
+import functools
+import sys
+import types
+import typing as ta
+import weakref
+
+from . import lang
+
+
+T = ta.TypeVar('T')
+
+
+_HOISTED_CODE_DEPTH: ta.MutableMapping[types.CodeType, int] = weakref.WeakKeyDictionary()
+_MAX_HOIST_DEPTH = 0
+
+
+def hoist(depth=0):
+    def inner(fn):
+        _HOISTED_CODE_DEPTH[fn.__code__] = depth
+        global _MAX_HOIST_DEPTH
+        _MAX_HOIST_DEPTH = max(_MAX_HOIST_DEPTH, depth)
+        return fn
+    return inner
+
+
+hoist()(contextlib.ExitStack.enter_context)  # noqa
+
+
+class MISSING(lang.Marker):
+    pass
+
+
+class UnboundVarError(ValueError):
+    pass
+
+
+class Var(ta.Generic[T]):
+
+    def __init__(
+            self,
+            default: ta.Union[type[MISSING], T] = MISSING,  # type: ignore
+            *,
+            new: ta.Union[ta.Callable[[], T], type[MISSING]] = MISSING,
+            validate: ta.Optional[ta.Callable[[T], None]] = None,
+    ) -> None:
+        super().__init__()
+
+        if default is not MISSING and new is not MISSING:
+            raise TypeError('Cannot set both default and new')
+        elif default is not MISSING:
+            new = lambda: default  # type: ignore
+        self._new: ta.Union[type[MISSING], ta.Callable[[], T]] = new
+        self._validate = validate
+        self._bindings_by_frame: ta.MutableMapping[types.FrameType, ta.MutableMapping[int, Binding]] = weakref.WeakValueDictionary()  # noqa
+
+    @ta.overload
+    def __call__(self) -> T:
+        ...
+
+    @ta.overload
+    def __call__(self, value: T, **kwargs: ta.Any) -> ta.ContextManager[T]:
+        ...
+
+    def __call__(self, *args, **kwargs):
+        if not args:
+            if kwargs:
+                raise TypeError(kwargs)
+            return self.value
+        elif len(args) == 1:
+            return self.binding(*args, **kwargs)
+        else:
+            raise TypeError(args)
+
+    def binding(self, value: T, *, offset: int = 0) -> ta.ContextManager[T]:
+        if self._validate is not None:
+            self._validate(self.value)
+        return Binding(self, value, offset=offset)
+
+    def with_binding(self, value):
+        def outer(fn):
+            @functools.wraps(fn)
+            def inner(*args, **kwargs):
+                with self.binding(value):
+                    return fn(*args, **kwargs)
+            return inner
+        return outer
+
+    def with_binding_fn(self, binding_fn):
+        this = self
+
+        def outer(fn):
+            class Descriptor:
+
+                @staticmethod
+                @functools.wraps(fn)
+                def __call__(*args, **kwargs):
+                    with this.binding(binding_fn(*args, **kwargs)):
+                        return fn(*args, **kwargs)
+
+                def __get__(self, obj, cls=None):
+                    bound_binding_fn = binding_fn.__get__(obj, cls)
+                    bound_fn = fn.__get__(obj, cls)
+
+                    @functools.wraps(fn)
+                    def inner(*args, **kwargs):
+                        with this.binding(bound_binding_fn(*args, **kwargs)):
+                            return bound_fn(*args, **kwargs)
+
+                    return inner
+
+            dct = dict((k, getattr(fn, k)) for k in functools.WRAPPER_ASSIGNMENTS)
+            return lang.new_type(fn.__name__, (Descriptor,), dct)()
+
+        return outer
+
+    @property
+    def values(self) -> ta.Iterator[T]:
+        frame = sys._getframe().f_back  # noqa
+        while frame:
+            try:
+                frame_bindings = self._bindings_by_frame[frame]
+            except KeyError:
+                pass
+            else:
+                for level, frame_binding in sorted(frame_bindings.items()):
+                    yield frame_binding._value  # noqa
+            frame = frame.f_back
+
+        if self._new is not MISSING:
+            yield self._new()
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return self.values
+
+    @property
+    def value(self) -> T:
+        try:
+            return next(self.values)
+        except StopIteration:
+            raise UnboundVarError
+
+
+class Binding(ta.Generic[T]):
+
+    _frame: types.FrameType
+    _frame_bindings: ta.MutableMapping[int, 'Binding']
+    _level: int
+
+    def __init__(self, var: Var[T], value: T, *, offset: int = 0) -> None:
+        super().__init__()
+
+        self._var = var
+        self._value = value
+        self._offset = offset
+
+    def __enter__(self) -> T:
+        frame = sys._getframe(self._offset).f_back  # noqa
+        lag_frame: ta.Optional[types.FrameType] = frame
+        while lag_frame is not None:
+            for cur_depth in range(_MAX_HOIST_DEPTH + 1):
+                if lag_frame is None:
+                    break  # type: ignore
+                try:
+                    lag_hoist = _HOISTED_CODE_DEPTH[lag_frame.f_code]
+                except KeyError:
+                    pass
+                else:
+                    if lag_hoist >= cur_depth:
+                        frame = lag_frame = lag_frame.f_back
+                        break
+                lag_frame = lag_frame.f_back
+            else:
+                break
+
+        if frame is None:
+            raise RuntimeError
+        self._frame = frame
+        try:
+            self._frame_bindings = self._var._bindings_by_frame[self._frame]  # noqa
+        except KeyError:
+            self._frame_bindings = self._var._bindings_by_frame[self._frame] = weakref.WeakValueDictionary()  # noqa
+            self._level = 0
+        else:
+            self._level = min(self._frame_bindings.keys() or [1]) - 1
+
+        self._frame_bindings[self._level] = self
+        return self._value
+
+    def __exit__(self, et, e, tb):
+        if self._frame_bindings[self._level] is not self:
+            raise TypeError
+
+        del self._frame_bindings[self._level]
+        del self._frame_bindings
+        del self._frame
+
+
+class _GeneratorContextManager(contextlib._GeneratorContextManager):  # noqa
+
+    @hoist(2)
+    def __enter__(self):
+        return super().__enter__()
+
+
+def contextmanager(fn):
+    @functools.wraps(fn)
+    def helper(*args, **kwds):
+        return _GeneratorContextManager(fn, args, kwds)
+    return helper  # noqa

omlish/graphs/dot/__init__.py

@@ -0,0 +1,19 @@
+from .items import Attrs  # noqa
+from .items import Cell  # noqa
+from .items import Edge  # noqa
+from .items import Graph  # noqa
+from .items import Id  # noqa
+from .items import Item  # noqa
+from .items import Node  # noqa
+from .items import Raw  # noqa
+from .items import RawStmt  # noqa
+from .items import Row  # noqa
+from .items import Stmt  # noqa
+from .items import Table  # noqa
+from .items import Text  # noqa
+from .rendering import Renderer  # noqa
+from .rendering import open_dot  # noqa
+from .rendering import render  # noqa
+from .utils import Color  # noqa
+from .utils import escape  # noqa
+from .utils import gen_rainbow  # noqa

omlish/graphs/dot/items.py

@@ -0,0 +1,162 @@
+"""
+https://github.com/chadbrewbaker/ReverseSnowflakeJoins/blob/master/dir.g lolwut
+ - https://github.com/chadbrewbaker/ReverseSnowflakeJoins/blob/5a1186843b47db0c94d976ca115efa6012b572ba/gui.py#L37
+ - * https://linux.die.net/man/1/gvpr *
+ - https://github.com/rodw/gvpr-lib
+"""
+import typing as ta
+
+from ... import check
+from ... import collections as col
+from ... import dataclasses as dc
+from ... import lang
+
+
+class Item(dc.Frozen, lang.Abstract, lang.Sealed):
+    pass
+
+
+class Value(Item, lang.Abstract):
+
+    @classmethod
+    def of(cls, obj: ta.Union['Value', str, ta.Sequence]) -> 'Value':
+        if isinstance(obj, Value):
+            return obj
+        elif isinstance(obj, str):
+            return Text(obj)
+        elif isinstance(obj, ta.Sequence):
+            return Table.of(obj)
+        else:
+            raise TypeError(obj)
+
+
+class Raw(Value):
+    raw: str
+
+    @classmethod
+    def of(cls, obj: ta.Union['Raw', str]) -> 'Raw':  # type: ignore
+        if isinstance(obj, Raw):
+            return obj
+        elif isinstance(obj, str):
+            return Raw(obj)
+        else:
+            raise TypeError(obj)
+
+
+class Text(Value):
+    text: str
+
+    @classmethod
+    def of(cls, obj: ta.Union['Text', str]) -> 'Text':  # type: ignore
+        if isinstance(obj, Text):
+            return obj
+        elif isinstance(obj, str):
+            return Text(obj)
+        else:
+            raise TypeError(obj)
+
+
+class Cell(Item):
+    value: Value
+
+    @classmethod
+    def of(cls, obj: ta.Union['Cell', ta.Any]) -> 'Cell':
+        if isinstance(obj, Cell):
+            return obj
+        else:
+            return Cell(Value.of(obj))
+
+
+class Row(Item):
+    cells: ta.Sequence[Cell] = dc.xfield(coerce=col.seq)
+
+    @classmethod
+    def of(cls, obj: ta.Union['Row', ta.Sequence[ta.Any]]) -> 'Row':
+        if isinstance(obj, Row):
+            return obj
+        elif isinstance(obj, str):
+            raise TypeError(obj)
+        elif isinstance(obj, ta.Sequence):
+            return Row([Cell.of(e) for e in obj])
+        else:
+            raise TypeError(obj)
+
+
+class Table(Value):
+    rows: ta.Sequence[Row] = dc.xfield(coerce=col.seq)
+
+    @classmethod
+    def of(cls, obj: ta.Union['Table', ta.Sequence[ta.Any]]) -> 'Table':  # type: ignore
+        if isinstance(obj, Table):
+            return obj
+        elif isinstance(obj, str):
+            raise TypeError(obj)
+        elif isinstance(obj, ta.Sequence):
+            return Table([Row.of(e) for e in obj])
+        else:
+            raise TypeError(obj)
+
+
+class Id(Item):
+    id: str
+
+    @classmethod
+    def of(cls, obj: ta.Union['Id', str]) -> 'Id':
+        if isinstance(obj, Id):
+            return obj
+        elif isinstance(obj, str):
+            return Id(obj)
+        else:
+            raise TypeError(obj)
+
+
+class Attrs(Item):
+    attrs: ta.Mapping[str, Value] = dc.field(
+        coerce=lambda o: col.frozendict(
+            (check.not_empty(check.isinstance(k, str)), Value.of(v))  # type: ignore
+            for k, v in check.isinstance(o, ta.Mapping).items()
+        )
+    )
+
+    @classmethod
+    def of(cls, obj: ta.Union['Attrs', ta.Mapping[str, ta.Any]]) -> 'Attrs':
+        if isinstance(obj, Attrs):
+            return obj
+        elif isinstance(obj, ta.Mapping):
+            return Attrs(obj)
+        else:
+            raise TypeError(obj)
+
+
+class Stmt(Item, lang.Abstract):
+    pass
+
+
+class RawStmt(Stmt):
+    raw: str
+
+    @classmethod
+    def of(cls, obj: ta.Union['RawStmt', str]) -> 'RawStmt':
+        if isinstance(obj, RawStmt):
+            return obj
+        elif isinstance(obj, str):
+            return RawStmt(obj)
+        else:
+            raise TypeError(obj)
+
+
+class Edge(Stmt):
+    left: Id = dc.xfield(coerce=Id.of)
+    right: Id = dc.xfield(coerce=Id.of)
+    attrs: Attrs = dc.xfield(default=Attrs({}), coerce=Attrs.of)
+
+
+class Node(Stmt):
+    id: Id = dc.xfield(coerce=Id.of)
+    attrs: Attrs = dc.xfield(default=Attrs({}), coerce=Attrs.of)
+
+
+class Graph(Item):
+    stmts: ta.Sequence[Stmt] = dc.xfield(coerce=col.seq)
+
+    id: Id = dc.xfield(default=Id('G'), kw_only=True)

omlish/graphs/dot/rendering.py

@@ -0,0 +1,147 @@
+import html
+import io
+import subprocess
+import tempfile
+import time
+import typing as ta
+
+from ... import dispatch
+from .items import Attrs
+from .items import Cell
+from .items import Edge
+from .items import Graph
+from .items import Id
+from .items import Item
+from .items import Node
+from .items import Raw
+from .items import RawStmt
+from .items import Row
+from .items import Table
+from .items import Text
+
+
+class Renderer:
+
+    def __init__(self, out: ta.TextIO) -> None:
+        super().__init__()
+
+        self._out = out
+
+    @dispatch.method
+    def render(self, item: Item) -> None:
+        raise TypeError(item)
+
+    @render.register
+    def render_raw(self, item: Raw) -> None:
+        self._out.write(item.raw)
+
+    @render.register
+    def render_text(self, item: Text) -> None:
+        self._out.write(html.escape(item.text))
+
+    @render.register
+    def render_cell(self, item: Cell) -> None:
+        self._out.write('<td>')
+        self.render(item.value)
+        self._out.write('</td>')
+
+    @render.register
+    def render_row(self, item: Row) -> None:
+        self._out.write('<tr>')
+        for cell in item.cells:
+            self.render(cell)
+        self._out.write('</tr>')
+
+    @render.register
+    def render_table(self, item: Table) -> None:
+        self._out.write('<table>')
+        for row in item.rows:
+            self.render(row)
+        self._out.write('</table>')
+
+    @render.register
+    def render_id(self, item: Id) -> None:
+        self._out.write(f'"{item.id}"')
+
+    @render.register
+    def render_attrs(self, item: Attrs) -> None:
+        if item.attrs:
+            self._out.write('[')
+            for i, (k, v) in enumerate(item.attrs.items()):
+                if i:
+                    self._out.write(', ')
+                self._out.write(k)
+                self._out.write('=<')
+                self.render(v)
+                self._out.write('>')
+            self._out.write(']')
+
+    @render.register
+    def render_raw_stmt(self, item: RawStmt) -> None:
+        self._out.write(item.raw)
+        self._out.write('\n')
+
+    @render.register
+    def render_edge(self, item: Edge) -> None:
+        self.render(item.left)
+        self._out.write(' -> ')
+        self.render(item.right)
+        if item.attrs.attrs:
+            self._out.write(' ')
+            self.render(item.attrs)
+        self._out.write(';\n')
+
+    @render.register
+    def render_node(self, item: Node) -> None:
+        self.render(item.id)
+        if item.attrs.attrs:
+            self._out.write(' ')
+            self.render(item.attrs)
+        self._out.write(';\n')
+
+    @render.register
+    def render_graph(self, item: Graph) -> None:
+        self._out.write('digraph ')
+        self.render(item.id)
+        self._out.write(' {\n')
+        for stmt in item.stmts:
+            self.render(stmt)
+        self._out.write('}\n')
+
+
+def render(item: Item) -> str:
+    out = io.StringIO()
+    Renderer(out).render(item)
+    return out.getvalue()
+
+
+def open_dot(
+        gv: str,
+        *,
+        timeout_s: float = 1.,
+        sleep_s: float = 0.,
+) -> None:
+    stdout, _ = subprocess.Popen(
+        ['dot', '-Tpdf'],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+    ).communicate(
+        input=gv.encode('utf-8'),
+        timeout=timeout_s,
+    )
+
+    with tempfile.NamedTemporaryFile(
+        suffix='.pdf',
+        delete=True,
+    ) as pdf:
+        pdf.file.write(stdout)
+        pdf.file.flush()
+
+        _, _ = subprocess.Popen(
+            ['open', pdf.name],
+        ).communicate(
+            timeout=timeout_s,
+        )
+
+        if sleep_s > 0.:
+            time.sleep(sleep_s)

omlish/graphs/dot/utils.py

@@ -0,0 +1,30 @@
+import html
+import typing as ta
+
+
+def escape(s: str) -> str:
+    return html.escape(s).replace('@', '@')
+
+
+class Color(ta.NamedTuple):
+    r: int
+    g: int
+    b: int
+
+
+def gen_rainbow(steps: int) -> list[Color]:
+    colors = []
+    for r in range(steps):
+        colors.append(Color(r * 255 // steps, 255, 0))
+    for g in range(steps, 0, -1):
+        colors.append(Color(255, g * 255 // steps, 0))
+    for b in range(steps):
+        colors.append(Color(255, 0, b * 255 // steps))
+    for r in range(steps, 0, -1):
+        colors.append(Color(r * 255 // steps, 0, 255))
+    for g in range(steps):
+        colors.append(Color(0, g * 255 // steps, 255))
+    for b in range(steps, 0, -1):
+        colors.append(Color(0, 255, b * 255 // steps))
+    colors.append(Color(0, 255, 0))
+    return colors