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

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
 
 
 ##

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

@@ -4,7 +4,7 @@ import typing as ta
 
 from omlish.lite.check import check
 
-from ..tokens import all as tks
+from .tokens import all as tks
 
 
 ##

omdev/py/tools/mkrelimp.py

@@ -6,7 +6,7 @@ import typing as ta
 from omlish.logs import all as logs
 
 from ...cli import CliModule
-from ...tokens import all as tks
+from ..tokens import all as tks
 
 
 T = ta.TypeVar('T')