omdev 0.0.0.dev440__py3-none-any.whl → 0.0.0.dev486__py3-none-any.whl

omdev/manifests/_dumping.py

@@ -34,11 +34,28 @@ if sys.version_info < (3, 8):
     raise OSError(f'Requires python (3, 8), got {sys.version_info} from {sys.executable}')  # noqa
 
 
+def __omlish_amalg__():  # noqa
+    return dict(
+        src_files=[
+            dict(path='../../omlish/lite/abstract.py', sha1='a2fc3f3697fa8de5247761e9d554e70176f37aac'),
+            dict(path='../../omlish/lite/cached.py', sha1='0c33cf961ac8f0727284303c7a30c5ea98f714f2'),
+            dict(path='../../omlish/lite/check.py', sha1='bb6b6b63333699b84462951a854d99ae83195b94'),
+            dict(path='../../omlish/lite/objects.py', sha1='9566bbf3530fd71fcc56321485216b592fae21e9'),
+            dict(path='../../omlish/lite/reflect.py', sha1='c4fec44bf144e9d93293c996af06f6c65fc5e63d'),
+            dict(path='../../omlish/lite/strings.py', sha1='89831ecbc34ad80e118a865eceb390ed399dc4d6'),
+            dict(path='../../omlish/lite/marshal.py', sha1='96348f5f2a26dc27d842d33cc3927e9da163436b'),
+            dict(path='dumping.py', sha1='49acd06fdcc3427f4a255fea295d7042bb655a13'),
+        ],
+    )
+
+
 ########################################
 
 
-# ../../omlish/lite/cached.py
+# ../../omlish/lite/abstract.py
 T = ta.TypeVar('T')
+
+# ../../omlish/lite/cached.py
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 # ../../omlish/lite/check.py
@@ -65,25 +82,49 @@ def is_abstract_method(obj: ta.Any) -> bool:
     return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
 
 
-def update_abstracts(cls, *, force=False):
+def compute_abstract_methods(cls: type) -> ta.FrozenSet[str]:
+    # ~> https://github.com/python/cpython/blob/f3476c6507381ca860eec0989f53647b13517423/Modules/_abc.c#L358
+
+    # Stage 1: direct abstract methods
+
+    abstracts = {
+        a
+        # Get items as a list to avoid mutation issues during iteration
+        for a, v in list(cls.__dict__.items())
+        if is_abstract_method(v)
+    }
+
+    # Stage 2: inherited abstract methods
+
+    for base in cls.__bases__:
+        # Get __abstractmethods__ from base if it exists
+        if (base_abstracts := getattr(base, _ABSTRACT_METHODS_ATTR, None)) is None:
+            continue
+
+        # Iterate over abstract methods in base
+        for key in base_abstracts:
+            # Check if this class has an attribute with this name
+            try:
+                value = getattr(cls, key)
+            except AttributeError:
+                # Attribute not found in this class, skip
+                continue
+
+            # Check if it's still abstract
+            if is_abstract_method(value):
+                abstracts.add(key)
+
+    return frozenset(abstracts)
+
+
+def update_abstracts(cls: ta.Type[T], *, force: bool = False) -> ta.Type[T]:
     if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
         # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
         # implementation (especially during testing), and we want to handle both cases.
         return cls
 
-    abstracts: ta.Set[str] = set()
-
-    for scls in cls.__bases__:
-        for name in getattr(scls, _ABSTRACT_METHODS_ATTR, ()):
-            value = getattr(cls, name, None)
-            if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-                abstracts.add(name)
-
-    for name, value in cls.__dict__.items():
-        if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-            abstracts.add(name)
-
-    setattr(cls, _ABSTRACT_METHODS_ATTR, frozenset(abstracts))
+    abstracts = compute_abstract_methods(cls)
+    setattr(cls, _ABSTRACT_METHODS_ATTR, abstracts)
     return cls
 
 
@@ -137,23 +178,26 @@ class Abstract:
         super().__init_subclass__(**kwargs)
 
         if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
-            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
-
-            seen = set(cls.__dict__)
-            for b in cls.__bases__:
-                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
-                seen.update(dir(b))
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
 
-            if ams:
                 raise AbstractTypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
                     ', '.join(sorted([
                         '.'.join([
-                            *([m] if (m := getattr(c, '__module__')) else []),
-                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            *([
+                                *([m] if (m := getattr(c, '__module__')) else []),
+                                getattr(c, '__qualname__', getattr(c, '__name__')),
+                            ] if c is not None else '?'),
                             a,
                         ])
-                        for a, c in ams.items()
+                        for a in ams
+                        for c in [amd.get(a)]
                     ])),
                 )
 
@@ -227,6 +271,62 @@ def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
     return _AsyncCachedNullary(fn)
 
 
+##
+
+
+cached_property = functools.cached_property
+
+
+class _cached_property:  # noqa
+    """Backported to pick up https://github.com/python/cpython/commit/056dfc71dce15f81887f0bd6da09d6099d71f979 ."""
+
+    def __init__(self, func):
+        self.func = func
+        self.attrname = None  # noqa
+        self.__doc__ = func.__doc__
+        self.__module__ = func.__module__
+
+    _NOT_FOUND = object()
+
+    def __set_name__(self, owner, name):
+        if self.attrname is None:
+            self.attrname = name  # noqa
+        elif name != self.attrname:
+            raise TypeError(
+                f'Cannot assign the same cached_property to two different names ({self.attrname!r} and {name!r}).',
+            )
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self.attrname is None:
+            raise TypeError('Cannot use cached_property instance without calling __set_name__ on it.')
+
+        try:
+            cache = instance.__dict__
+        except AttributeError:  # not all objects have __dict__ (e.g. class defines slots)
+            raise TypeError(
+                f"No '__dict__' attribute on {type(instance).__name__!r} instance to cache {self.attrname!r} property.",
+            ) from None
+
+        val = cache.get(self.attrname, self._NOT_FOUND)
+
+        if val is self._NOT_FOUND:
+            val = self.func(instance)
+            try:
+                cache[self.attrname] = val
+            except TypeError:
+                raise TypeError(
+                    f"The '__dict__' attribute on {type(instance).__name__!r} instance does not support item "
+                    f"assignment for caching {self.attrname!r} property.",
+                ) from None
+
+        return val
+
+
+globals()['cached_property'] = _cached_property
+
+
 ########################################
 # ../../../omlish/lite/check.py
 """

omdev/markdown/incparse.py

@@ -0,0 +1,116 @@
+import dataclasses as dc
+import typing as ta
+
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    import markdown_it as md
+    import markdown_it.token  # noqa
+
+
+##
+
+
+class IncrementalMarkdownParser:
+    def __init__(
+            self,
+            *,
+            parser: ta.Optional['md.MarkdownIt'] = None,
+    ) -> None:
+        super().__init__()
+
+        if parser is None:
+            parser = md.MarkdownIt()
+        self._parser = parser
+
+        self._stable_tokens: list[md.token.Token] = []
+        self._buffer = ''
+        self._num_stable_lines = 0  # Number of lines in stable tokens
+
+    class FeedOutput(ta.NamedTuple):
+        stable: ta.Sequence['md.token.Token']
+        new_stable: ta.Sequence['md.token.Token']
+        unstable: ta.Sequence['md.token.Token']
+
+    def feed2(self, chunk: str) -> FeedOutput:
+        self._buffer += chunk
+
+        # Parse the current buffer
+        new_tokens = self._parser.parse(self._buffer)
+
+        # Adjust ALL tokens to account for stable lines from previous parses (new_tokens have line numbers relative to
+        # current buffer)
+        adjusted_tokens = self._adjust_token_line_numbers(new_tokens, self._num_stable_lines)
+
+        # Find stable tokens (all but the last parent and its children)
+        stable_count = self._find_stable_token_count(adjusted_tokens)
+
+        newly_stable: ta.Sequence[md.token.Token]
+        if stable_count > 0:
+            # Extract newly stable tokens (already have adjusted line numbers)
+            newly_stable = adjusted_tokens[:stable_count]
+
+            # Calculate how many lines these stable tokens cover
+            max_line = 0
+            for token in newly_stable:
+                if token.map:
+                    max_line = max(max_line, token.map[1])
+
+            # Update buffer to only contain unstable content
+            if max_line > self._num_stable_lines:
+                # max_line is absolute, num_stable_lines is the current buffer offset
+                lines_to_remove = max_line - self._num_stable_lines
+                lines = self._buffer.split('\n')
+                self._buffer = '\n'.join(lines[lines_to_remove:])
+
+                # Store newly stable tokens (with adjusted line numbers)
+                self._stable_tokens.extend(newly_stable)
+                self._num_stable_lines = max_line
+
+        else:
+            newly_stable = ()
+
+        return IncrementalMarkdownParser.FeedOutput(
+            stable=self._stable_tokens,
+            new_stable=newly_stable,
+            unstable=adjusted_tokens[stable_count:],
+        )
+
+    def feed(self, chunk: str) -> list['md.token.Token']:
+        out = self.feed2(chunk)
+        return [*out.stable, *out.unstable]
+
+    def _find_stable_token_count(self, tokens: list['md.token.Token']) -> int:
+        if not tokens:
+            return 0
+
+        # Find indices of all parent-level tokens (nesting = 0)
+        parent_indices = []
+        for i, token in enumerate(tokens):
+            if token.nesting in (1, 0) and token.level == 0:
+                parent_indices.append(i)
+
+        if len(parent_indices) < 2:
+            # Need at least 2 parent tokens to have stable content
+            return 0
+
+        # The last parent and everything after it is unstable. Everything before the second-to-last parent is stable.
+        return parent_indices[-2]
+
+    def _adjust_token_line_numbers(
+            self,
+            tokens: list['md.token.Token'],
+            line_offset: int,
+    ) -> list['md.token.Token']:
+        adjusted = []
+        for token in tokens:
+            if token.map:
+                token = dc.replace(
+                    token,
+                    map=[token.map[0] + line_offset, token.map[1] + line_offset],
+                )
+
+            adjusted.append(token)
+
+        return adjusted

omdev/markdown/tokens.py

@@ -0,0 +1,51 @@
+# ruff: noqa: TC002
+import typing as ta
+
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    import markdown_it as md
+    import markdown_it.token  # noqa
+
+
+##
+
+
+def token_repr(t: 'md.token.Token') -> str:
+    return ''.join([
+        'Token(',
+        f'type={t.type!r}',
+        *([f', tag={t.tag!r}'] if t.tag else []),
+        *([f', nesting={t.nesting!r}'] if t.nesting else []),
+        *([f', attrs={t.attrs!r}'] if t.attrs else []),
+        *([f', map={t.map!r}'] if t.map else []),
+        *([f', level={t.level!r}'] if t.level else []),
+        *([f', children={t.children!r}'] if t.children else []),
+        *([f', content={t.content!r}'] if t.content else []),
+        *([f', markup={t.markup!r}'] if t.markup else []),
+        *([f', info={t.info!r}'] if t.info else []),
+        *([f', meta={t.meta!r}'] if t.meta else []),
+        *([f', block={t.block!r}'] if t.block else []),
+        *([f', hidden={t.hidden!r}'] if t.hidden else []),
+        ')',
+    ])
+
+
+##
+
+
+def flatten_tokens(
+        tokens: ta.Iterable['md.token.Token'],
+        *,
+        filter: ta.Callable[['md.token.Token'], bool] | None = None,  # noqa
+) -> ta.Iterable['md.token.Token']:
+    def rec(tks: ta.Iterable['md.token.Token']) -> ta.Iterator['md.token.Token']:
+        for tk in tks:
+            if tk.children and not (filter is not None and not filter(tk)):
+                yield from rec(tk.children)
+
+            else:
+                yield tk
+
+    return rec(tokens)

omdev/packaging/marshal.py

@@ -8,7 +8,6 @@ import typing as ta
 from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
-from omlish.funcs import match as mfs
 
 from .requires import RequiresMarkerItem
 from .requires import RequiresMarkerList
@@ -43,12 +42,13 @@ class RequiresMarkerListMarshaler(msh.Marshaler):
         return [inner(e) for e in o]
 
 
-class RequiresMarkerListMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalRequiresMarkerList)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return RequiresMarkerListMarshaler(
-            ctx.make(RequiresMarkerItem),
-            ctx.make(RequiresNode),
+class RequiresMarkerListMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not MarshalRequiresMarkerList:
+            return None
+        return lambda: RequiresMarkerListMarshaler(
+            ctx.make_marshaler(RequiresMarkerItem),
+            ctx.make_marshaler(RequiresNode),
         )
 
 
@@ -56,7 +56,7 @@ class RequiresMarkerListMarshalerFactory(msh.MarshalerFactoryMatchClass):
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     requires_node_poly = msh.Polymorphism(
         RequiresNode,
         [

omdev/packaging/requires.py

@@ -33,6 +33,12 @@ from omlish.lite.check import check
 from .specifiers import Specifier
 
 
+RequiresMarkerVar = ta.Union['RequiresVariable', 'RequiresValue']  # ta.TypeAlias
+
+RequiresMarkerAtom = ta.Union['RequiresMarkerItem', ta.Sequence['RequiresMarkerAtom']]  # ta.TypeAlias
+RequiresMarkerList = ta.Sequence[ta.Union['RequiresMarkerList', 'RequiresMarkerAtom', str]]  # ta.TypeAlias
+
+
 ##
 
 
@@ -229,12 +235,6 @@ class RequiresOp(RequiresNode):
         return str(self)
 
 
-RequiresMarkerVar = ta.Union['RequiresVariable', 'RequiresValue']
-
-RequiresMarkerAtom = ta.Union['RequiresMarkerItem', ta.Sequence['RequiresMarkerAtom']]
-RequiresMarkerList = ta.Sequence[ta.Union['RequiresMarkerList', 'RequiresMarkerAtom', str]]
-
-
 class RequiresMarkerItem(ta.NamedTuple):
     l: ta.Union[RequiresVariable, RequiresValue]
     op: RequiresOp

omdev/packaging/specifiers.py

@@ -451,7 +451,7 @@ class SpecifierSet(BaseSpecifier):
         if isinstance(other, str):
             other = SpecifierSet(other)
         elif not isinstance(other, SpecifierSet):
-            return NotImplemented  # type: ignore
+            return NotImplemented
 
         specifier = SpecifierSet()
         specifier._specs = frozenset(self._specs | other._specs)
@@ -471,6 +471,7 @@ class SpecifierSet(BaseSpecifier):
         if isinstance(other, (str, Specifier)):
             other = SpecifierSet(str(other))
         elif not isinstance(other, SpecifierSet):
+
             return NotImplemented
 
         return self._specs == other._specs

omdev/packaging/versions.py

@@ -121,12 +121,12 @@ class _BaseVersion:
 
     def __lt__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key < other._key
 
     def __le__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key <= other._key
 
     def __eq__(self, other: object) -> bool:
@@ -136,12 +136,12 @@ class _BaseVersion:
 
     def __ge__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key >= other._key
 
     def __gt__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key > other._key
 
     def __ne__(self, other: object) -> bool:

omdev/packaging/wheelfile.py

@@ -116,11 +116,13 @@ class WheelFile(zipfile.ZipFile):
     @staticmethod
     def _urlsafe_b64encode(data: bytes) -> bytes:
         """urlsafe_b64encode without padding"""
+
         return base64.urlsafe_b64encode(data).rstrip(b'=')
 
     @staticmethod
     def _urlsafe_b64decode(data: bytes) -> bytes:
         """urlsafe_b64decode without padding"""
+
         pad = b'=' * (4 - (len(data) & 3))
         return base64.urlsafe_b64decode(data + pad)
 

omdev/precheck/blanklines.py

@@ -0,0 +1,66 @@
+import dataclasses as dc
+import os
+import typing as ta
+
+from omlish.text.filecache import TextFileCache
+
+from .base import Precheck
+from .base import PrecheckContext
+from .caches import DirWalkCache
+from .caches import HeadersCache
+
+
+##
+
+
+class BlankLinesPrecheck(Precheck['BlankLinesPrecheck.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(Precheck.Config):
+        DEFAULT_FILE_EXTENSIONS: ta.ClassVar[ta.AbstractSet[str]] = frozenset([
+            'py',
+
+            'c',
+            'cc',
+            'cu',
+            'h',
+            'hh',
+        ])
+
+        file_extensions: ta.AbstractSet[str] = DEFAULT_FILE_EXTENSIONS
+
+    def __init__(
+            self,
+            context: PrecheckContext,
+            config: Config = Config(),
+            *,
+            dir_walk_cache: DirWalkCache,
+            text_file_cache: TextFileCache,
+            headers_cache: HeadersCache,
+    ) -> None:
+        super().__init__(config)
+
+        self._context = context
+
+        self._dir_walk_cache = dir_walk_cache
+        self._text_file_cache = text_file_cache
+        self._headers_cache = headers_cache
+
+    async def _run_file(self, file: str) -> ta.AsyncGenerator[Precheck.Violation]:
+        src = self._text_file_cache.get_entry(file).text()
+
+        if src and not src.splitlines()[0]:
+            yield Precheck.Violation(self, f'source file {file} starts with blank line')
+
+    async def run(self) -> ta.AsyncGenerator[Precheck.Violation]:
+        files = [
+            os.path.join(e.root, f)
+            for src_root in self._context.src_roots
+            for e in self._dir_walk_cache.list_dir(src_root)
+            for f in e.files
+            if '.' in f
+            and any(f.endswith('.' + ext) for ext in self._config.file_extensions)
+        ]
+
+        for file in sorted(files):
+            async for v in self._run_file(file):
+                yield v

omdev/precheck/caches.py

@@ -8,7 +8,7 @@ from omlish.text.filecache import TextFileCache
 
 from ..py.srcheaders import PyHeaderLine
 from ..py.srcheaders import get_py_header_lines
-from ..tokens import all as tks
+from ..py.tokens import all as tks
 
 
 ##

omdev/precheck/imports.py

@@ -3,6 +3,8 @@ import dataclasses as dc
 import os.path
 import typing as ta
 
+from omlish.text.filecache import TextFileCache
+
 from .base import Precheck
 from .base import PrecheckContext
 from .caches import AstCache
@@ -26,6 +28,7 @@ class RootRelativeImportPrecheck(Precheck['RootRelativeImportPrecheck.Config']):
             dir_walk_cache: DirWalkCache,
             headers_cache: HeadersCache,
             ast_cache: AstCache,
+            text_file_cache: TextFileCache,
     ) -> None:
         super().__init__(config)
 
@@ -34,6 +37,7 @@ class RootRelativeImportPrecheck(Precheck['RootRelativeImportPrecheck.Config']):
         self._dir_walk_cache = dir_walk_cache
         self._headers_cache = headers_cache
         self._ast_cache = ast_cache
+        self._text_file_cache = text_file_cache
 
     async def _run_py_file(self, py_file: str, src_root: str) -> ta.AsyncGenerator[Precheck.Violation]:
         if isinstance(header_lines := self._headers_cache.get_file_headers(py_file), Exception):
@@ -41,11 +45,20 @@ class RootRelativeImportPrecheck(Precheck['RootRelativeImportPrecheck.Config']):
         if any(hl.src.strip() == '# ruff: noqa' for hl in header_lines):
             return
 
+        py_file_lines = self._text_file_cache.get_entry(py_file).lines()
+
         py_file_ast = self._ast_cache.get_file_ast(py_file)
         if not isinstance(py_file_ast, ast.Module):
             return
 
-        for cur_node in py_file_ast.body:
+        for cur_node in ast.walk(py_file_ast):
+            if not isinstance(cur_node, (ast.Import, ast.ImportFrom)):
+                continue
+
+            # FIXME: lame lol
+            if py_file_lines[cur_node.lineno - 1].strip().endswith('# noqa'):
+                continue
+
             if isinstance(cur_node, ast.Import):
                 imp_alias: ast.alias
                 for imp_alias in cur_node.names:

omdev/precheck/main.py

@@ -21,7 +21,6 @@ TODO:
 import argparse
 import asyncio
 import os.path
-import sys
 import typing as ta
 
 from omlish import inject as inj
@@ -29,6 +28,7 @@ from omlish.logs import all as logs
 
 from .base import Precheck
 from .base import PrecheckContext
+from .blanklines import BlankLinesPrecheck
 from .caches import AstCache
 from .caches import DirWalkCache
 from .caches import HeadersCache
@@ -87,6 +87,7 @@ def _check_cmd(args) -> None:
     )
 
     pc_cfgs: list[Precheck.Config] = [
+        BlankLinesPrecheck.Config(),
         GitBlacklistPrecheck.Config(),
         LitePython8Precheck.Config(),
         ManifestsPrecheck.Config(),
@@ -124,7 +125,7 @@ def _check_cmd(args) -> None:
 
         if vs:
             print(f'{len(vs)} violations found')
-            sys.exit(1)
+            raise SystemExit(1)
 
 
 ##
@@ -132,12 +133,12 @@ def _check_cmd(args) -> None:
 
 def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser()
+    parser.add_argument('-v', '--verbose', action='store_true')
 
     subparsers = parser.add_subparsers()
 
     parser_check = subparsers.add_parser('check')
     parser_check.add_argument('roots', nargs='+')
-    parser_check.add_argument('-v', '--verbose', action='store_true')
     parser_check.set_defaults(func=_check_cmd)
 
     return parser