omlish 0.0.0.dev295__py3-none-any.whl → 0.0.0.dev297__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev295'
-__revision__ = 'eb4e318f611f286b283b0afe04a4d6acb13ca8ee'
+__version__ = '0.0.0.dev297'
+__revision__ = '60d7844496d6c1b510da1f34cb05a64b5f8c1f6d'
 
 
 #
@@ -107,6 +107,8 @@ class Project(ProjectBase):
         ],
 
         'templates': [
+            'markupsafe ~= 3.0',
+
             'jinja2 ~= 3.1',
         ],
 

omlish/collections/__init__.py

@@ -77,11 +77,14 @@ from .ordered import (  # noqa
 
 from .persistent.persistent import (  # noqa
     PersistentMap,
+    PersistentMapping,
 )
 
 if _ta.TYPE_CHECKING:
     from .persistent.treapmap import (  # noqa
+        TreapDict,
         TreapMap,
+        new_treap_dict,
         new_treap_map,
     )
 else:
@@ -108,6 +111,8 @@ else:
 
 from .sorted.sorted import (  # noqa
     SortedCollection,
+    SortedItems,
+    SortedIter,
     SortedListDict,
     SortedMapping,
     SortedMutableMapping,

omlish/collections/persistent/persistent.py

@@ -1,6 +1,8 @@
 import abc
 import typing as ta
 
+from ... import lang
+
 
 K = ta.TypeVar('K')
 V = ta.TypeVar('V')
@@ -9,7 +11,7 @@ V = ta.TypeVar('V')
 ##
 
 
-class PersistentMap(ta.Generic[K, V], abc.ABC):
+class PersistentMap(lang.Abstract, ta.Generic[K, V]):
     @abc.abstractmethod
     def __len__(self) -> int:
         raise NotImplementedError
@@ -23,17 +25,36 @@ class PersistentMap(ta.Generic[K, V], abc.ABC):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def __iter__(self) -> ta.Iterator[tuple[K, V]]:
+    def __iter__(self) -> ta.Iterator[K]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def items(self) -> ta.Iterator[tuple[K, V]]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def with_(self, k: K, v: V) -> 'PersistentMap[K, V]':
+    def with_(self, k: K, v: V) -> ta.Self:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def without(self, k: K) -> 'PersistentMap[K, V]':
+    def without(self, k: K) -> ta.Self:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def default(self, k: K, v: V) -> ta.Self:
+        raise NotImplementedError
+
+
+class PersistentMapping(
+    PersistentMap[K, V],
+    ta.Mapping[K, V],
+    lang.Abstract,
+    ta.Generic[K, V],
+):
+    @abc.abstractmethod
+    def __contains__(self, item: K) -> bool:  # type: ignore[override]
         raise NotImplementedError
 
     @abc.abstractmethod
-    def default(self, k: K, v: V) -> 'PersistentMap[K, V]':
+    def items(self) -> ta.Iterator[tuple[K, V]]:  # type: ignore[override]  # FIXME: ItemsView
         raise NotImplementedError

omlish/collections/persistent/treapmap.py

@@ -20,8 +20,10 @@ import abc
 import random
 import typing as ta
 
+from ..sorted.sorted import SortedItems
 from . import treap
 from .persistent import PersistentMap
+from .persistent import PersistentMapping
 
 
 K = ta.TypeVar('K')
@@ -31,7 +33,7 @@ V = ta.TypeVar('V')
 ##
 
 
-class TreapMap(PersistentMap[K, V]):
+class TreapMap(PersistentMap[K, V], SortedItems[K, V]):
     __slots__ = ('_n', '_c')
 
     def __init__(
@@ -69,10 +71,10 @@ class TreapMap(PersistentMap[K, V]):
             raise KeyError(item)
         return n.value
 
-    def __iter__(self) -> ta.Iterator[tuple[K, V]]:
+    def __iter__(self) -> ta.Iterator[K]:
         i = self.items()
         while i.has_next():
-            yield i.next()
+            yield i.next()[0]
 
     def items(self) -> 'TreapMapIterator[K, V]':
         i = TreapMapIterator(
@@ -84,14 +86,6 @@ class TreapMap(PersistentMap[K, V]):
             i._n = n.left  # noqa
         return i
 
-    def items_from(self, k: K) -> 'TreapMapIterator[K, V]':
-        lst = treap.place(self._n, (k, None), self._c)  # type: ignore
-        i = TreapMapIterator(
-            _st=lst,
-            _n=lst.pop(),
-        )
-        return i
-
     def items_desc(self) -> 'TreapMapReverseIterator[K, V]':
         i = TreapMapReverseIterator(
             _st=[],
@@ -102,6 +96,14 @@ class TreapMap(PersistentMap[K, V]):
             i._n = n.right  # noqa
         return i
 
+    def items_from(self, k: K) -> 'TreapMapIterator[K, V]':
+        lst = treap.place(self._n, (k, None), self._c)  # type: ignore
+        i = TreapMapIterator(
+            _st=lst,
+            _n=lst.pop(),
+        )
+        return i
+
     def items_from_desc(self, k: K) -> 'TreapMapReverseIterator[K, V]':
         lst = treap.place(self._n, (k, None), self._c, desc=True)  # type: ignore
         i = TreapMapReverseIterator(
@@ -137,7 +139,22 @@ def new_treap_map(cmp: ta.Callable[[tuple[K, V], tuple[K, V]], int]) -> Persiste
     return TreapMap(_n=None, _c=cmp)
 
 
-class BaseTreapMapIterator(abc.ABC, ta.Generic[K, V]):
+#
+
+
+class TreapDict(TreapMap[K, V], PersistentMapping[K, V]):
+    __contains__ = TreapMap.__contains__
+    items = TreapMap.items
+
+
+def new_treap_dict(cmp: ta.Callable[[tuple[K, V], tuple[K, V]], int]) -> PersistentMapping[K, V]:
+    return TreapDict(_n=None, _c=cmp)
+
+
+##
+
+
+class BaseTreapMapIterator(abc.ABC, ta.Iterator[tuple[K, V]], ta.Generic[K, V]):
     __slots__ = ('_st', '_n')
 
     def __init__(
@@ -151,6 +168,12 @@ class BaseTreapMapIterator(abc.ABC, ta.Generic[K, V]):
         self._st = _st
         self._n = _n
 
+    def __iter__(self) -> ta.Self:
+        return self
+
+    def __next__(self) -> tuple[K, V]:
+        return self.next()
+
     def has_next(self) -> bool:
         return self._n is not None
 

omlish/collections/sorted/skiplist.py

@@ -170,30 +170,38 @@ class SkipList(SortedCollection[T]):
 
     #
 
-    def iter(self, base: T | None = None) -> ta.Iterable[T]:
-        if base is not None:
-            cur = self._find(base)
-            while cur is not None and self._compare(base, cur.value) > 0:  # type: ignore
-                cur = cur.next[0]
-        else:
-            cur = self._head.next[0]
+    def iter(self) -> ta.Iterator[T]:
+        cur = self._head.next[0]
 
         while cur is not None:
             yield cur.value  # type: ignore
             cur = cur.next[0]
 
-    def iter_desc(self, base: T | None = None) -> ta.Iterable[T]:
-        if base is not None:
-            cur = self._find(base)
-            while cur is not self._head and self._compare(base, cur.value) < 0:  # type: ignore
-                cur = cur.prev  # type: ignore
-        else:
-            cur = self._head.next[self._height - 1]
-            while True:
-                next = cur.next[cur.next.index(None) - 1 if None in cur.next else -1]  # type: ignore  # noqa
-                if next is None:
-                    break
-                cur = next
+    def iter_desc(self) -> ta.Iterator[T]:
+        cur = self._head.next[self._height - 1]
+        while True:
+            next = cur.next[cur.next.index(None) - 1 if None in cur.next else -1]  # type: ignore  # noqa
+            if next is None:
+                break
+            cur = next
+
+        while cur is not self._head:
+            yield cur.value  # type: ignore
+            cur = cur.prev  # type: ignore
+
+    def iter_from(self, base: T) -> ta.Iterator[T]:
+        cur = self._find(base)
+        while cur is not None and self._compare(base, cur.value) > 0:  # type: ignore
+            cur = cur.next[0]
+
+        while cur is not None:
+            yield cur.value  # type: ignore
+            cur = cur.next[0]
+
+    def iter_from_desc(self, base: T) -> ta.Iterator[T]:
+        cur = self._find(base)
+        while cur is not self._head and self._compare(base, cur.value) < 0:  # type: ignore
+            cur = cur.prev  # type: ignore
 
         while cur is not self._head:
             yield cur.value  # type: ignore

omlish/collections/sorted/sorted.py

@@ -13,7 +13,30 @@ V = ta.TypeVar('V')
 ##
 
 
-class SortedCollection(lang.Abstract, ta.Collection[T]):
+class SortedIter(lang.Abstract, ta.Generic[T]):
+    @abc.abstractmethod
+    def iter(self) -> ta.Iterator[T]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def iter_desc(self) -> ta.Iterator[T]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def iter_from(self, base: T) -> ta.Iterator[T]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def iter_from_desc(self, base: T) -> ta.Iterator[T]:
+        raise NotImplementedError
+
+
+class SortedCollection(
+    SortedIter[T],
+    ta.Collection[T],
+    lang.Abstract,
+    ta.Generic[T],
+):
     Comparator = ta.Callable[[U, U], int]
 
     @staticmethod
@@ -46,18 +69,13 @@ class SortedCollection(lang.Abstract, ta.Collection[T]):
     def remove(self, value: T) -> bool:
         raise NotImplementedError
 
-    @abc.abstractmethod
-    def iter(self, base: T | None = None) -> ta.Iterable[T]:
-        raise NotImplementedError
 
-    @abc.abstractmethod
-    def iter_desc(self, base: T | None = None) -> ta.Iterable[T]:
-        raise NotImplementedError
+#
 
 
-class SortedMapping(ta.Mapping[K, V]):
+class SortedItems(lang.Abstract, ta.Generic[K, V]):
     @abc.abstractmethod
-    def items(self) -> ta.Iterator[tuple[K, V]]:  # type: ignore
+    def items(self) -> ta.Iterator[tuple[K, V]]:
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -73,10 +91,29 @@ class SortedMapping(ta.Mapping[K, V]):
         raise NotImplementedError
 
 
-class SortedMutableMapping(ta.MutableMapping[K, V], SortedMapping[K, V]):
+class SortedMapping(
+    SortedItems[K, V],
+    ta.Mapping[K, V],
+    lang.Abstract,
+    ta.Generic[K, V],
+):
+    @abc.abstractmethod
+    def items(self) -> ta.Iterator[tuple[K, V]]:  # type: ignore[override]  # FIXME: ItemsView
+        raise NotImplementedError
+
+
+class SortedMutableMapping(
+    ta.MutableMapping[K, V],
+    SortedMapping[K, V],
+    lang.Abstract,
+    ta.Generic[K, V],
+):
     pass
 
 
+##
+
+
 class SortedListDict(SortedMutableMapping[K, V]):
     @staticmethod
     def _item_comparator(a: tuple[K, V], b: tuple[K, V]) -> int:
@@ -119,7 +156,7 @@ class SortedListDict(SortedMutableMapping[K, V]):
         yield from self._impl.iter_desc()
 
     def items_from(self, key: K) -> ta.Iterator[tuple[K, V]]:
-        yield from self._impl.iter((key, None))
+        yield from self._impl.iter_from((key, None))
 
     def items_from_desc(self, key: K) -> ta.Iterator[tuple[K, V]]:
-        yield from self._impl.iter_desc((key, None))
+        yield from self._impl.iter_from_desc((key, None))

omlish/dataclasses/generation/processor.py

@@ -11,6 +11,7 @@ import typing as ta
 from ... import check
 from ... import lang
 from ..processing.base import ProcessingContext
+from ..processing.base import ProcessingOption
 from ..processing.base import Processor
 from ..processing.priority import ProcessorPriority
 from ..processing.registry import register_processor_type
@@ -32,11 +33,13 @@ from .registry import generator_type_for_plan_type
 ##
 
 
-class PlanOnly(ta.NamedTuple):
+@dc.dataclass(frozen=True)
+class PlanOnly(ProcessingOption):
     b: bool
 
 
-class Verbose(ta.NamedTuple):
+@dc.dataclass(frozen=True)
+class Verbose(ProcessingOption):
     b: bool
 
 

omlish/dataclasses/processing/base.py

@@ -13,6 +13,7 @@ from ..specs import ClassSpec
 
 
 T = ta.TypeVar('T')
+ProcessingOptionT = ta.TypeVar('ProcessingOptionT', bound='ProcessingOption')
 
 
 ##
@@ -21,6 +22,10 @@ T = ta.TypeVar('T')
 ProcessingContextItemFactory: ta.TypeAlias = ta.Callable[['ProcessingContext'], ta.Any]
 
 
+class ProcessingOption(lang.Abstract):
+    pass
+
+
 class ProcessingContext:
     def __init__(
             self,
@@ -28,7 +33,7 @@ class ProcessingContext:
             cs: ClassSpec,
             item_factories: ta.Mapping[type, ProcessingContextItemFactory],
             *,
-            options: ta.Sequence[ta.Any] | None = None,
+            options: ta.Sequence[ProcessingOption] | None = None,
     ) -> None:
         super().__init__()
 
@@ -63,7 +68,7 @@ class ProcessingContext:
         self._items[ty] = ret
         return ret
 
-    def option(self, ty: type[T]) -> T | None:
+    def option(self, ty: type[ProcessingOptionT]) -> ProcessingOptionT | None:
         return self._options_dct.get(ty)
 
 

omlish/dataclasses/processing/driving.py

@@ -1,9 +1,9 @@
-import typing as ta
 
 from .. import concerns as _concerns  # noqa  # imported for registration
 from ..generation import processor as gp
 from ..specs import ClassSpec
 from .base import ProcessingContext
+from .base import ProcessingOption
 from .base import Processor
 from .registry import all_processing_context_item_factories
 from .registry import ordered_processor_types
@@ -19,7 +19,7 @@ def drive_cls_processing(
         plan_only: bool = False,
         verbose: bool = False,
 ) -> type:
-    options: list[ta.Any] = []
+    options: list[ProcessingOption] = []
     if plan_only:
         options.append(gp.PlanOnly(True))
     if verbose:

omlish/dom/__init__.py

@@ -0,0 +1,26 @@
+from .building import (  # noqa
+    d,
+    D,
+)
+
+from .content import (  # noqa
+    String,
+    Content,
+
+    Dom,
+
+    STRING_TYPES,
+    CONTENT_TYPES,
+
+    check_content,
+    iter_content,
+)
+
+from .rendering import (  # noqa
+    InvalidTagError,
+    StrForbiddenError,
+
+    Renderer,
+
+    render,
+)

omlish/dom/building.py

@@ -0,0 +1,54 @@
+import typing as ta
+
+from .. import dataclasses as dc
+from .content import Content
+from .content import Dom
+from .content import kwargs_to_attrs
+
+
+##
+
+
+def d(
+        tag: str,
+        *attrs_and_contents: tuple[str, ta.Any] | Content,
+        **kwargs: ta.Any,
+) -> Dom:
+    c = []
+    for a in attrs_and_contents:
+        if isinstance(a, tuple):
+            k, v = a
+            if k in kwargs:
+                raise KeyError(f'Attribute {k} already set')
+            kwargs[k] = v
+        else:
+            c.append(a)
+
+    return Dom(
+        tag,
+        attrs=kwargs_to_attrs(**kwargs) or None,
+        body=c or None,
+    )
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DomBuilder:
+    tag: str
+
+    def __call__(
+            self,
+            *attrs_and_contents: tuple[str, ta.Any] | Content,
+            **kwargs: ta.Any,
+    ) -> Dom:
+        return d(self.tag, *attrs_and_contents, **kwargs)
+
+
+class DomAccessor:
+    def __getattr__(self, tag: str) -> DomBuilder:
+        return DomBuilder(tag)
+
+
+D = DomAccessor()

omlish/dom/content.py

@@ -0,0 +1,129 @@
+import keyword
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import markupsafe as ms
+
+    _HAS_MARKUPSAFE = True
+
+else:
+    ms = lang.proxy_import('markupsafe')
+
+    _HAS_MARKUPSAFE = lang.can_import('markupsafe')
+
+
+String: ta.TypeAlias = ta.Union[
+    str,
+    'ms.Markup',
+]
+
+Content: ta.TypeAlias = ta.Union[
+    list['Content'],
+    'Dom',
+    String,
+    None,
+]
+
+ContentT = ta.TypeVar('ContentT', bound=Content)
+
+
+##
+
+
+ATTR_NAMES_BY_KWARG: ta.Mapping[str, str] = {
+    **{f'{k}_': k for k in keyword.kwlist if k == k.lower()},
+}
+
+ATTR_KWARGS_BY_NAME: ta.Mapping[str, str] = {v: k for k, v in ATTR_NAMES_BY_KWARG.items()}
+
+
+def kwargs_to_attrs(**kwargs: ta.Any) -> dict[str, ta.Any]:
+    return {
+        ATTR_NAMES_BY_KWARG.get(k, k).replace('_', '-'): v
+        for k, v in kwargs.items()
+    }
+
+
+##
+
+
+@dc.dataclass()
+class Dom:
+    tag: str
+    attrs: dict[str, ta.Any | None] | None = dc.xfield(None, repr_fn=lang.opt_repr)
+    body: list[Content] | None = dc.xfield(None, repr_fn=lang.opt_repr)
+
+    def set(self, **kwargs: ta.Any) -> 'Dom':
+        if self.attrs is None:
+            self.attrs = {}
+        self.attrs.update(**kwargs_to_attrs(**kwargs))
+        return self
+
+    def unset(self, *keys: str) -> 'Dom':
+        if self.attrs is not None:
+            for k in keys:
+                self.attrs.pop(k, None)
+        return self
+
+    def add(self, *contents: Content) -> 'Dom':
+        if self.body is None:
+            self.body = []
+        for c in contents:
+            check_content(c)
+        self.body.extend(contents)
+        return self
+
+    def remove(self, *contents: Content, strict: bool = False) -> 'Dom':
+        if self.body is not None:
+            i = 0
+            while i < len(self.body):
+                e = self.body[i]
+                if any(c is e for c in contents):
+                    del self.body[i]
+                elif strict:
+                    raise ValueError(f'Content {e} not in body')
+                else:
+                    i += 1
+        return self
+
+
+##
+
+
+STRING_TYPES: tuple[type, ...] = (
+    str,
+    *([ms.Markup] if _HAS_MARKUPSAFE else []),
+)
+
+CONTENT_TYPES: tuple[type, ...] = (
+    list,
+    Dom,
+    *STRING_TYPES,
+    type(None),
+)
+
+
+def check_content(c: ContentT) -> ContentT:
+    if isinstance(c, list):
+        for e in c:
+            check_content(e)
+    else:
+        check.isinstance(c, CONTENT_TYPES)
+    return c
+
+
+def iter_content(c: Content) -> ta.Iterator[Dom | String]:
+    if isinstance(c, list):
+        for e in c:
+            yield from iter_content(e)
+    elif isinstance(c, (Dom, *STRING_TYPES)):
+        yield c  # type: ignore[misc]
+    elif c is None:
+        pass
+    else:
+        raise TypeError(c)