omdev 0.0.0.dev416__py3-none-any.whl → 0.0.0.dev500__py3-none-any.whl

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/lite.py

@@ -2,13 +2,13 @@ import asyncio
 import dataclasses as dc
 import glob
 import inspect
-import logging
 import os.path
 import subprocess
 import textwrap
 import typing as ta
 
 from omlish import cached
+from omlish.logs import all as logs
 from omlish.subprocesses.wrap import subprocess_maybe_shell_wrap_exec
 
 from .. import magic
@@ -16,7 +16,7 @@ from .base import Precheck
 from .base import PrecheckContext
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 ##

omdev/precheck/main.py

@@ -20,9 +20,7 @@ TODO:
 """
 import argparse
 import asyncio
-import logging
 import os.path
-import sys
 import typing as ta
 
 from omlish import inject as inj
@@ -30,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
@@ -43,7 +42,7 @@ from .scripts import ScriptDepsPrecheck
 from .unicode import UnicodePrecheck
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 ##
@@ -88,6 +87,7 @@ def _check_cmd(args) -> None:
     )
 
     pc_cfgs: list[Precheck.Config] = [
+        BlankLinesPrecheck.Config(),
         GitBlacklistPrecheck.Config(),
         LitePython8Precheck.Config(),
         ManifestsPrecheck.Config(),
@@ -125,7 +125,7 @@ def _check_cmd(args) -> None:
 
         if vs:
             print(f'{len(vs)} violations found')
-            sys.exit(1)
+            raise SystemExit(1)
 
 
 ##
@@ -133,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

omdev/precheck/unicode.py

@@ -29,6 +29,18 @@ class UnicodePrecheck(Precheck['UnicodePrecheck.Config']):
 
         permitted_categories: ta.AbstractSet[str] = DEFAULT_PERMITTED_CATEGORIES
 
+        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,
@@ -46,19 +58,15 @@ class UnicodePrecheck(Precheck['UnicodePrecheck.Config']):
         self._text_file_cache = text_file_cache
         self._headers_cache = headers_cache
 
-    async def _run_py_file(self, py_file: str) -> ta.AsyncGenerator[Precheck.Violation]:
-        if isinstance(header_lines := self._headers_cache.get_file_headers(py_file), Exception):
-            return
-        if any(hl.src.strip() == '# @omlish-precheck-allow-any-unicode' for hl in header_lines):
-            return
-
-        src = self._text_file_cache.get_entry(py_file).text()
+    async def _run_file(self, file: str, src: str | None = None) -> ta.AsyncGenerator[Precheck.Violation]:
+        if src is None:
+            src = self._text_file_cache.get_entry(file).text()
 
         illegal_chars = {
             ch
             for ch in src
-            if ord(ch) > 255 and
-            unicodedata.category(ch) not in self._config.permitted_categories
+            if ord(ch) > 255
+            and unicodedata.category(ch) not in self._config.permitted_categories
         }
 
         if illegal_chars:
@@ -66,16 +74,32 @@ class UnicodePrecheck(Precheck['UnicodePrecheck.Config']):
                 f'({ch!r}, {unicodedata.category(ch)})'
                 for ch in sorted(illegal_chars)
             ]
-            yield Precheck.Violation(self, f'source file {py_file} has illegal unicode characters: {", ".join(sl)}')
+            yield Precheck.Violation(self, f'source file {file} has illegal unicode characters: {", ".join(sl)}')
+
+    async def _run_py_file(self, py_file: str) -> ta.AsyncGenerator[Precheck.Violation]:
+        if isinstance(header_lines := self._headers_cache.get_file_headers(py_file), Exception):
+            return
+        if any(hl.src.strip() == '# @omlish-precheck-allow-any-unicode' for hl in header_lines):
+            return
+
+        async for v in self._run_file(py_file):
+            yield v
 
     async def run(self) -> ta.AsyncGenerator[Precheck.Violation]:
-        py_files = [
+        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 f.endswith('.py')
+            if '.' in f
+            and any(f.endswith('.' + ext) for ext in self._config.file_extensions)
         ]
-        for py_file in sorted(py_files):
-            async for v in self._run_py_file(py_file):
-                yield v
+
+        for file in sorted(files):
+            if file.endswith('.py'):
+                async for v in self._run_py_file(file):
+                    yield v
+
+            else:
+                async for v in self._run_file(file):
+                    yield v

omdev/py/asts/parents.py

@@ -0,0 +1,28 @@
+import ast
+
+from omlish import check
+
+
+##
+
+
+class _ParentsNodeVisitor(ast.NodeVisitor):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.parents: dict[ast.AST, ast.AST | None] = {}
+
+    parent: ast.AST | None = None
+
+    def generic_visit(self, node: ast.AST) -> None:
+        check.not_in(node, self.parents)
+        prev_parent = self.parents[node] = self.parent
+        self.parent = node
+        super().generic_visit(node)
+        self.parent = prev_parent
+
+
+def get_node_parents(node: ast.AST) -> dict[ast.AST, ast.AST | None]:
+    visitor = _ParentsNodeVisitor()
+    visitor.visit(node)
+    return visitor.parents

omdev/py/asts/toplevel.py

@@ -0,0 +1,123 @@
+"""
+Quite, quite lame, but sufficient for immediate needs. Accurate static symbol resolution is in development but can't
+block other work.
+"""
+import ast
+import dataclasses as dc
+import typing as ta
+
+from omlish import check
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class TopLevelImport:
+    spec: str
+    name: str
+    node: ast.Import | ast.ImportFrom
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class TopLevelCall:
+    node: ast.Call
+    imp: TopLevelImport
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class TopLevelFindings:
+    imports: ta.Mapping[str, TopLevelImport]
+    calls: ta.Sequence[TopLevelCall]
+
+
+##
+
+
+class _TopLevelModuleVisitor(ast.NodeVisitor):
+    def __init__(self, module_name: str) -> None:
+        super().__init__()
+
+        self.module_name = module_name
+        self.module_name_parts = module_name.split('.')
+
+        self.imports: dict[str, TopLevelImport] = {}
+        self.calls: list[TopLevelCall] = []
+
+    #
+
+    def visit_Import(self, node: ast.Import) -> None:
+        for alias in node.names:
+            name = alias.asname if alias.asname else alias.name
+            self.imports[name] = TopLevelImport(
+                spec=alias.name,
+                name=name,
+                node=node,
+            )
+
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        if node.level:
+            check.state(node.level < len(self.module_name_parts))
+            module = '.'.join([
+                *self.module_name_parts[:-node.level],
+                *([node.module] if node.module else []),
+            ])
+        else:
+            module = check.not_none(node.module)
+
+        for alias in node.names:
+            name = alias.asname if alias.asname else alias.name
+            self.imports[name] = TopLevelImport(
+                spec='.'.join([module, alias.name]),
+                name=name,
+                node=node,
+            )
+
+        self.generic_visit(node)
+
+    #
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        pass
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        pass
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        pass
+
+    #
+
+    def handle_call(self, node: ast.Call) -> None:
+        if not (
+                isinstance(attr := node.func, ast.Attribute) and
+                isinstance(attr.ctx, ast.Load) and
+                isinstance(name := attr.value, ast.Name) and
+                isinstance(name.ctx, ast.Load)
+        ):
+            return
+
+        if (imp := self.imports.get(name.id)) is None:
+            return
+
+        self.calls.append(TopLevelCall(
+            node=node,
+            imp=imp,
+        ))
+
+    def visit_Call(self, node: ast.Call) -> None:
+        self.handle_call(node)
+
+
+def analyze_module_top_level(
+        module: ast.Module,
+        module_name: str,
+) -> TopLevelFindings:
+    visitor = _TopLevelModuleVisitor(module_name)
+    visitor.visit(module)
+    return TopLevelFindings(
+        imports=visitor.imports,
+        calls=visitor.calls,
+    )

omdev/py/asts/visitors.py

@@ -0,0 +1,18 @@
+import ast
+
+from omlish import check
+
+
+##
+
+
+class StackNodeVisitor(ast.NodeVisitor):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.node_stack: list[ast.AST] = []
+
+    def generic_visit(self, node: ast.AST) -> None:
+        self.node_stack.append(node)
+        super().generic_visit(node)
+        check.is_(self.node_stack.pop(), node)

omdev/py/attrdocs.py

@@ -12,7 +12,7 @@ import typing as ta
 from omlish import check
 from omlish import lang
 
-from ..tokens import all as tks
+from .tokens import all as tks
 
 
 ##
@@ -24,12 +24,11 @@ class AttrDoc:
     trailing_comment: str | None = None
     preceding_comment: str | None = None
 
-    __repr__ = lang.AttrRepr.of(
-        'docstring',
-        'trailing_comment',
-        'preceding_comment',
-        value_filter=bool,
-    )
+    __repr__ = lang.attr_ops(lambda o: (
+        o.docstring,
+        o.trailing_comment,
+        o.preceding_comment,
+    ), repr_filter=bool).repr
 
 
 _EMPTY_ATTR_DOC = AttrDoc()

omdev/py/bracepy.py

@@ -101,18 +101,26 @@ _CLI_MODULE = {'!.cli.types.CliModule': {
 if __name__ == '__main__':
     def _main(argv=None) -> None:
         import argparse
+        import sys
 
         parser = argparse.ArgumentParser()
         parser.add_argument('-x', '--exec', action='store_true')
-        parser.add_argument('cmd')
+        parser.add_argument('-i', '--indent', type=int)
+        parser.add_argument('code', nargs='?')
 
         args = parser.parse_args(argv)
 
-        src = translate_brace_python(args.cmd)
+        if (code := args.code) is None:
+            code = sys.stdin.read()
+
+        out = translate_brace_python(
+            code,
+            **(dict(indent_width=args.indent) if args.indent is not None else {}),
+        )
 
         if args.exec:
-            exec(src)
+            exec(out)
         else:
-            print(src)
+            print(out)
 
     _main()

omdev/py/docstrings/numpydoc.py

@@ -74,7 +74,7 @@ class Section:
         dashes = '-' * len(self.title)
         return rf'^({self.title})\s*?\n{dashes}\s*$'
 
-    def parse(self, text: str) -> ta.Iterable[DocstringMeta]:
+    def parse(self, text: str) -> ta.Iterator[DocstringMeta]:
         """
         Parse ``DocstringMeta`` objects from the body of this section.
 
@@ -100,7 +100,7 @@ class _KVSection(Section, abc.ABC):
     def _parse_item(self, key: str, value: str) -> DocstringMeta:
         raise NotImplementedError
 
-    def parse(self, text: str) -> ta.Iterable[DocstringMeta]:
+    def parse(self, text: str) -> ta.Iterator[DocstringMeta]:
         for match, next_match in _pairwise(KV_PAT.finditer(text)):
             start = match.end()
             end = next_match.start() if next_match is not None else None
@@ -227,7 +227,7 @@ class YieldsSection(ReturnsSection):
 class DeprecationSection(_SphinxSection):
     """Parser for numpydoc "deprecation warning" sections."""
 
-    def parse(self, text: str) -> ta.Iterable[DocstringDeprecated]:
+    def parse(self, text: str) -> ta.Iterator[DocstringDeprecated]:
         version, desc, *_ = [*text.split(sep='\n', maxsplit=1), None, None]
 
         if desc is not None:
@@ -254,7 +254,7 @@ class ExamplesSection(Section):
                 [ 6586976, 22740995]])
     """
 
-    def parse(self, text: str) -> ta.Iterable[DocstringMeta]:
+    def parse(self, text: str) -> ta.Iterator[DocstringMeta]:
         """
         Parse ``DocstringExample`` objects from the body of this section.
 

omdev/py/reprs.py

@@ -0,0 +1,32 @@
+def textwrap_repr(text: str, width: int = 120, quote_char: str = '"') -> list[str]:
+    escaped_quote = '\\' + quote_char
+    content_width = width - 2
+
+    lines: list[str] = []
+    current_line: list[str] = []
+    current_length = 0
+
+    for char in text:
+        if char == quote_char:
+            safe_char = escaped_quote
+        elif char == '\\':
+            safe_char = '\\\\'
+        elif not char.isprintable():
+            safe_char = repr(char)[1:-1]
+            if quote_char in safe_char:
+                safe_char = safe_char.replace(quote_char, escaped_quote)
+        else:
+            safe_char = char
+
+        if current_length + len(safe_char) > content_width:
+            lines.append(f"{quote_char}{''.join(current_line)}{quote_char}")
+            current_line = []
+            current_length = 0
+
+        current_line.append(safe_char)
+        current_length += len(safe_char)
+
+    if current_line:
+        lines.append(f"{quote_char}{''.join(current_line)}{quote_char}")
+
+    return lines

omdev/py/scripts/execstat.py

@@ -17,13 +17,14 @@ import typing as ta
 
 
 def _run(
+        report: 'ta.Callable[[dict], None]',
         src: str,
         *,
         setup: 'ta.Optional[str]' = None,
         time: bool = False,
         rss: bool = False,
         modules: bool = False,
-) -> dict:
+) -> None:
     if rss:
         import resource  # noqa
 
@@ -61,26 +62,28 @@ def _run(
 
     #
 
-    exec(code, globals(), ns)
+    try:
+        exec(code, globals(), ns)
 
-    #
+    finally:
+        #
 
-    if time:
-        end_time = get_time()
+        if time:
+            end_time = get_time()
 
-    if rss:
-        end_rss = get_rss()
+        if rss:
+            end_rss = get_rss()
 
-    if modules:
-        end_modules = get_modules()
+        if modules:
+            end_modules = get_modules()
 
-    #
+        #
 
-    return {
-        **({'time': (end_time - start_time)} if time else {}),  # noqa
-        **({'rss': (end_rss - start_rss)} if rss else {}),  # noqa
-        **({'modules': [m for m in end_modules if m not in start_modules]} if modules else {}),  # noqa
-    }
+        report({
+            **({'time': (end_time - start_time)} if time else {}),  # noqa
+            **({'rss': (end_rss - start_rss)} if rss else {}),  # noqa
+            **({'modules': [m for m in end_modules if m not in start_modules]} if modules else {}),  # noqa
+        })
 
 
 #
@@ -145,13 +148,10 @@ def _main() -> None:
 
         payload = '\n'.join([
             inspect.getsource(_run),
-            f'dct = _run(**{run_kw!r})',
-            f'import json',
-            f'with open({out_file!r}, "w") as f:',  # noqa
-            f'    f.write(json.dumps(dct))',
+            f'with open({out_file!r}, "w") as f: _run(lambda dct: f.write(__import__("json").dumps(dct)), **{run_kw!r})',  # noqa
         ])
 
-        subprocess.check_call([exe, '-c', payload])
+        subprocess.call([exe, '-c', payload])
 
         with open(out_file) as f:
             result = json.load(f)
@@ -185,14 +185,19 @@ def _main() -> None:
             'rss_s': f'{rss:_}',
         })
 
-    if args.modules:
+    if args.modules or args.modules_ordered:
+        mods = results[0]['modules']
         out.update({
-            'modules': sorted(results[0]['modules']),
-        })
-    if args.modules_ordered:
-        out.update({
-            'modules_ordered': results[0]['modules'],
+            'num_modules': len(mods),
         })
+        if args.modules:
+            out.update({
+                'modules': sorted(mods),
+            })
+        if args.modules_ordered:
+            out.update({
+                'modules_ordered': mods,
+            })
 
     print(json.dumps(out, indent=2))