coretrace-python-analyzer 0.24.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

coretrace_python/__init__.py

@@ -1,4 +1,4 @@
 """CoreTrace's Python static analysis frontend."""
 
-__version__ = "0.24.0"
+__version__ = "0.25.0"
 

coretrace_python/source/__init__.py

@@ -1,6 +1,12 @@
 """Source storage and location primitives."""
 
-from coretrace_python.source.manager import LINE_BREAK, SourceManager, decode_text, lines_of
+from coretrace_python.source.manager import (
+    LINE_BREAK,
+    LineIndex,
+    SourceManager,
+    decode_text,
+    lines_of,
+)
 from coretrace_python.source.model import (
     FileLocation,
     ImportName,
@@ -14,6 +20,7 @@ __all__ = [
     "LINE_BREAK",
     "FileLocation",
     "ImportName",
+    "LineIndex",
     "Location",
     "SourceFile",
     "SourceId",

coretrace_python/source/manager.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import re
+from bisect import bisect_right
 from pathlib import Path
 
 from coretrace_python.source.model import ImportName, SourceFile, SourceId
@@ -86,6 +87,26 @@ def lines_of(text: str) -> list[str]:
     return lines
 
 
+class LineIndex:
+    """The line and column of each offset of a text, lines counted as ``lines_of``
+    counts them. The start of each line is found once; the line of an offset is then
+    found by bisection, in time logarithmic in the lines."""
+
+    def __init__(self, text: str) -> None:
+        self._starts = [0, *(match.end() for match in LINE_BREAK.finditer(text))]
+
+    def position(self, offset: int) -> tuple[int, int]:
+        """The one-based line and column of ``offset``."""
+
+        line = bisect_right(self._starts, offset)
+        return line, offset - self._starts[line - 1] + 1
+
+    def offset(self, line: int, column: int) -> int:
+        """The offset of the one-based ``line`` and ``column``."""
+
+        return self._starts[line - 1] + column - 1
+
+
 class SourceManager:
     """Own source text and return one canonical object for each source ID."""
 

coretrace_python/source/positions.py

@@ -16,9 +16,8 @@ import hashlib
 import json
 import re
 import tomllib
-from bisect import bisect_right
 
-from coretrace_python.source.manager import LINE_BREAK, lines_of
+from coretrace_python.source.manager import LineIndex, lines_of
 from coretrace_python.source.model import FileLocation, SourceId
 
 Pointer = tuple[str | int, ...]
@@ -54,22 +53,6 @@ def pointer_text(path: Pointer) -> str:
     return "".join("/" + str(part).replace("~", "~0").replace("/", "~1") for part in path)
 
 
-class _Lines:
-    def __init__(self, text: str) -> None:
-        self._starts = [0, *(match.end() for match in LINE_BREAK.finditer(text))]
-
-    def position(self, offset: int) -> tuple[int, int]:
-        """The one-based line and column of ``offset``."""
-
-        line = bisect_right(self._starts, offset)
-        return line, offset - self._starts[line - 1] + 1
-
-    def offset(self, line: int, column: int) -> int:
-        """The offset of the one-based ``line`` and ``column``."""
-
-        return self._starts[line - 1] + column - 1
-
-
 def _same(found: object, value: object) -> bool:
     return type(found) is type(value) and found == value
 
@@ -87,7 +70,7 @@ class JsonPositions:
                 raise ValueError("trailing text")
         except (ValueError, IndexError, RecursionError):
             self._values = {}
-        self._lines = _Lines(text)
+        self._lines = LineIndex(text)
 
     def locate(self, path: Pointer, value: object) -> tuple[int, int] | None:
         """The line and column ``value`` starts at under ``path``, or None when the text
@@ -183,7 +166,7 @@ class TomlPositions:
         self._lines = lines_of(text)
         # The text with one line feed per line break, where arrays are read, once each.
         self._text = "\n".join(self._lines)
-        self._offsets = _Lines(self._text)
+        self._offsets = LineIndex(self._text)
         self._arrays: dict[int, list[tuple[int, int]]] = {}
         state = _LexState()
         for number, line in enumerate(self._lines, start=1):

coretrace_python/taint/templates.py

@@ -53,7 +53,7 @@ from __future__ import annotations
 import re
 from bisect import bisect_left
 from collections import deque
-from collections.abc import Container, Iterable, Iterator, Mapping, Sequence
+from collections.abc import Callable, Container, Iterable, Iterator, Mapping, Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
 from types import MappingProxyType
@@ -79,7 +79,7 @@ from coretrace_python.semantic.scopes import (
     analyze_scopes,
 )
 from coretrace_python.semantic.symbols import SymbolId, analyze_symbols
-from coretrace_python.source import SourceId, SourceManager, SourceSpan
+from coretrace_python.source import LineIndex, SourceId, SourceManager, SourceSpan
 from coretrace_python.taint.models import ModelTable
 
 TEMPLATES_DIRECTORY = "templates"
@@ -935,13 +935,13 @@ class _Application:
 
 @dataclass(frozen=True)
 class _Reference:
-    """A template another one includes, or ``extends``, at ``offset`` in its ``blocks``:
+    """A template another one includes, or ``extends``, at ``span`` in its ``blocks``:
     by ``name``, None when an expression names it. The referenced template's free names
     are ``bindings``, then, unless ``only``, what the ``scope`` binds there, then the
     referencing template's."""
 
     name: str | None
-    offset: int
+    span: SourceSpan
     bindings: Mapping[str, frozenset[str]] = field(default_factory=dict)
     only: bool = False
     scope: Mapping[str, frozenset[str]] = field(default_factory=dict)
@@ -961,12 +961,12 @@ class _Reference:
 
 @dataclass(frozen=True)
 class _Load:
-    """A ``{% load %}`` of ``library`` at ``offset``, of the ``names`` it selects
+    """A ``{% load %}`` of ``library`` at ``span``, of the ``names`` it selects
     (``{% load a b from lib %}``), None for the whole library."""
 
     library: str
     names: frozenset[str] | None
-    offset: int
+    span: SourceSpan
 
 
 @dataclass(frozen=True)
@@ -989,29 +989,16 @@ class _Library:
 @dataclass(frozen=True)
 class _Template:
     """What one template file applies and references, the ``blocks`` it defines, and
-    among them the ``extended`` ones, which render ``{{ block.super }}``, and the loads
-    under which it applies a filter the engine could not resolve."""
+    among them the ``extended`` ones, which render ``{{ block.super }}``, the loads under
+    which it applies a filter the engine could not resolve, and the block each block
+    stands in, None for one standing in none (#285)."""
 
     applications: tuple[_Application, ...]
     references: tuple[_Reference, ...]
     blocks: frozenset[str]
     extended: frozenset[str] = frozenset()
     unresolved: tuple[_Load, ...] = ()
-
-    def rendered(self, blocks: tuple[str, ...], overridden: frozenset[str]) -> bool:
-        """Whether what stands in ``blocks`` renders when a template extending this one
-        defines the ``overridden`` blocks: a template extending another renders only
-        its blocks, where they replace the blocks of that name in what it extends."""
-
-        extends = any(reference.extends for reference in self.references)
-        return not overridden.intersection(blocks) and (bool(blocks) or not extends)
-
-    @property
-    def replaced(self) -> frozenset[str]:
-        """The blocks this template replaces in what it extends: those it defines
-        without rendering ``{{ block.super }}``, which keeps the parent's content."""
-
-        return self.blocks - self.extended
+    enclosing: Mapping[str, str | None] = field(default_factory=dict)
 
 
 def project_templates(root: Path) -> ProjectTemplates:
@@ -1040,7 +1027,7 @@ def project_templates(root: Path) -> ProjectTemplates:
             continue
         read[path] = _read_scopes(text, SourceId(str(path)), libraries)
         for reference in read[path].references:
-            where = f"{relative}:{_position(text, reference.offset)[0]}"
+            where = f"{relative}:{reference.span.start_line}"
             if reference.name is None:
                 unread.append(f"{where} names a template by an expression")
             elif reference.name not in files:
@@ -1048,16 +1035,15 @@ def project_templates(root: Path) -> ProjectTemplates:
         for load in read[path].unresolved:
             library = libraries.get(load.library)
             reason = "not found" if library is None else "not read" if library.uncertain is None else "found in several files"
-            unread.append(f"{relative}:{_position(text, load.offset)[0]} loads {load.library!r}, {reason}")
+            unread.append(f"{relative}:{load.span.start_line} loads {load.library!r}, {reason}")
     calls = tuple(FilterCall(a.symbol, a.span) for template in read.values() for a in template.applications)
-    # The filters each template reaches, by template and blocks overridden, for this
-    # analysis only (#279).
-    reached: dict[tuple[str, frozenset[str]], _Walk] = {}
+    # What each template reaches rendered on its own, for this analysis only.
+    settled = _settled(files, read)
     filters = {
         name: tuple(
             dict.fromkeys(
                 TemplateFilter(symbol, span, where, tuple(sorted(value)), tuple(sorted(argument)))
-                for symbol, span, where, value, argument in _reaching(name, files, read, frozenset(), frozenset(), reached).found
+                for symbol, span, where, value, argument in settled.get(name, ())
             )
         )
         for name in files
@@ -1070,70 +1056,245 @@ def project_templates(root: Path) -> ProjectTemplates:
 _Reached = tuple[SymbolId, SourceSpan, str, frozenset[str], frozenset[str]]
 
 
-class _Walk(NamedTuple):
-    """What a walk of a template found; whether a cycle of includes cut it short; and the
-    templates it went through."""
-
-    found: list[_Reached]
-    cut: bool
-    walked: frozenset[str]
-
-
-_NOTHING = _Walk([], cut=False, walked=frozenset())
-
-
-def _reaching(
-    name: str,
-    files: Mapping[str, list[Path]],
-    read: Mapping[Path, _Template],
-    visiting: frozenset[str],
-    overridden: frozenset[str],
-    reached: dict[tuple[str, frozenset[str]], _Walk],
-) -> _Walk:
-    """The filters rendering the template ``name`` applies, in it and in what it includes
-    or extends, each with the template applying it and the names free in ``name`` whose
-    values reach its value and its argument; the templates extending ``name`` on the way
-    define the ``overridden`` blocks. A template already ``visiting`` cuts the walk short.
-
-    Each template is walked once for each set of blocks overridden (#279): ``reached``
-    keeps what a walk found, its first occurrences in order, which mapped through a
-    reference give the first occurrences a walk path by path gives. A walk depends on
-    ``visiting`` only where a cycle cuts it, so one cut short is not kept, and one that
-    went through a template now on the way is not reused: walked from there, it would be
-    cut at that template."""
-
-    paths = files.get(name, [])
-    if len(paths) != 1 or paths[0] not in read:
-        return _NOTHING
-    if name in visiting:
-        return _Walk([], cut=True, walked=frozenset())
-    kept = reached.get((name, overridden))
-    if kept is not None and visiting.isdisjoint(kept.walked):
-        return kept
-    template = read[paths[0]]
-    found: dict[_Reached, None] = {}
-    cut = False
-    walked = {name}
-    for application in template.applications:
-        if template.rendered(application.blocks, overridden):
-            found.setdefault((application.symbol, application.span, name, application.value, application.argument))
-    for reference in template.references:
-        if reference.name is None:
+class _Render(NamedTuple):
+    """What rendering a template on its own applies, and the templates it includes, each
+    with its reference."""
+
+    applied: tuple[_Reached, ...]
+    references: tuple[tuple[str, _Reference], ...]
+
+
+def _page(name: str, readable: Callable[[str | None], _Template | None]) -> _Render:
+    """What rendering ``name`` on its own applies and includes, its extends chain put
+    together as Django puts it (#285).
+
+    The chain runs from ``name`` up to its root, the template extending none. The root's
+    blocks standing in no other block are placed; a placed block renders its most derived
+    definition, then, while a definition renders ``{{ block.super }}``, the next one up;
+    the blocks a rendered definition holds are placed in turn. A filter or an include
+    renders when the definition of the innermost block it stands in renders; outside
+    every block, only in the root, Django ignoring a child's text outside its blocks.
+
+    When the chain reaches no known root, as through a parent named by an expression, a
+    name several files have, a file the engine cannot read, or an extends cycle Django
+    refuses, every block of the chain is placed: no filter is dropped on a placement the
+    engine cannot establish.
+
+    What the chain applies is listed from ``name`` up to the root, and what it includes
+    from the root down to ``name``: the order of a walk of each path through extends."""
+
+    chain: list[tuple[str, _Template]] = []
+    seen: set[str] = set()
+    known = True
+    current: str | None = name
+    while True:
+        template = readable(current)
+        if current is None or template is None or current in seen:
+            known = False
+            break
+        chain.append((current, template))
+        seen.add(current)
+        parent = next((reference for reference in template.references if reference.extends), None)
+        if parent is None:
+            break
+        current = parent.name
+    defining: dict[str, list[int]] = {}
+    held: dict[tuple[int, str | None], list[str]] = {}
+    for level, (_, template) in enumerate(chain):
+        for block in template.blocks:
+            defining.setdefault(block, []).append(level)
+            held.setdefault((level, template.enclosing.get(block)), []).append(block)
+    pending = list(held.get((len(chain) - 1, None), ())) if known else list(defining)
+    placed: set[str] = set()
+    shown: set[tuple[int, str]] = set()
+    while pending:
+        block = pending.pop()
+        if block in placed:
             continue
-        if reference.extends:
-            below = _reaching(reference.name, files, read, visiting | {name}, overridden | template.replaced, reached)
-        elif template.rendered(reference.blocks, overridden):
-            below = _reaching(reference.name, files, read, visiting | {name}, frozenset(), reached)
-        else:
+        placed.add(block)
+        for level in defining.get(block, []):
+            shown.add((level, block))
+            pending.extend(held.get((level, block), ()))
+            if block not in chain[level][1].extended:
+                break
+
+    def renders(level: int, blocks: tuple[str, ...]) -> bool:
+        return (level, blocks[-1]) in shown if blocks else known and level == len(chain) - 1
+
+    applied = tuple(
+        (application.symbol, application.span, template_name, application.value, application.argument)
+        for level, (template_name, template) in enumerate(chain)
+        for application in template.applications
+        if renders(level, application.blocks)
+    )
+    references = tuple(
+        (reference.name, reference)
+        for level in reversed(range(len(chain)))
+        for reference in chain[level][1].references
+        if not reference.extends
+        and reference.name is not None
+        and readable(reference.name) is not None
+        and renders(level, reference.blocks)
+    )
+    return _Render(applied, references)
+
+
+def _renders(files: Mapping[str, list[Path]], read: Mapping[Path, _Template]) -> dict[str, _Render]:
+    """What rendering each template on its own applies and includes. A name several files
+    have, or a file the engine could not read, renders nothing."""
+
+    def readable(name: str | None) -> _Template | None:
+        paths = files.get(name or "", [])
+        return read[paths[0]] if len(paths) == 1 and paths[0] in read else None
+
+    return {name: _page(name, readable) for name in files if readable(name) is not None}
+
+
+def _components(renders: Mapping[str, _Render]) -> list[list[str]]:
+    """The strongly connected components of the renders, each after every component its
+    references reach: Tarjan's algorithm, without recursion."""
+
+    index: dict[str, int] = {}
+    low: dict[str, int] = {}
+    stack: list[str] = []
+    on_stack: set[str] = set()
+    components: list[list[str]] = []
+    for root in renders:
+        if root in index:
             continue
-        cut = cut or below.cut
-        walked |= below.walked
-        for symbol, span, where, value, argument in below.found:
-            found.setdefault((symbol, span, where, reference.maps(value), reference.maps(argument)))
-    walk = _Walk(list(found), cut, frozenset(walked))
-    if not cut:
-        reached[name, overridden] = walk
-    return walk
+        # Each entry is a template and the position of the next reference to follow.
+        work = [(root, 0)]
+        while work:
+            current, position = work.pop()
+            if position == 0:
+                index[current] = low[current] = len(index)
+                stack.append(current)
+                on_stack.add(current)
+            references = renders[current].references
+            for following in range(position, len(references)):
+                below = references[following][0]
+                if below not in index:
+                    work.append((current, following + 1))
+                    work.append((below, 0))
+                    break
+                if below in on_stack:
+                    low[current] = min(low[current], index[below])
+            else:
+                if low[current] == index[current]:
+                    component: list[str] = []
+                    while not component or component[-1] != current:
+                        component.append(stack.pop())
+                        on_stack.discard(component[-1])
+                    components.append(component)
+                if work:
+                    parent = work[-1][0]
+                    low[parent] = min(low[parent], low[current])
+    return components
+
+
+def _mapped(found: Iterable[_Reached], reference: _Reference) -> Iterator[_Reached]:
+    """The filters a referenced template reaches, their names mapped through the reference."""
+
+    for symbol, span, where, value, argument in found:
+        yield symbol, span, where, reference.maps(value), reference.maps(argument)
+
+
+def _canonical(found: _Reached) -> tuple[str, int, int, str, list[str], list[str]]:
+    """The order of the filters a template in a cycle reaches beyond what it applies."""
+
+    symbol, span, where, value, argument = found
+    return where, span.start_line, span.start_column, str(symbol), sorted(value), sorted(argument)
+
+
+# A filter application: the function, where it is applied, and the template applying it.
+_Site = tuple[SymbolId, SourceSpan, str]
+
+
+def _joined(found: Iterable[_Reached], into: dict[_Site, tuple[frozenset[str], frozenset[str]]]) -> None:
+    """Join into ``into`` the names reaching the value and the argument of each filter
+    application ``found`` holds."""
+
+    for symbol, span, where, value, argument in found:
+        values, arguments = into.get((symbol, span, where), (frozenset(), frozenset()))
+        into[symbol, span, where] = values | value, arguments | argument
+
+
+def _facts(names: Mapping[_Site, tuple[frozenset[str], frozenset[str]]], sites: Iterable[_Site]) -> list[_Reached]:
+    """The filters at ``sites``, each with the names joined at its application."""
+
+    return [(symbol, span, where, *names[symbol, span, where]) for symbol, span, where in sites]
+
+
+def _settled(files: Mapping[str, list[Path]], read: Mapping[Path, _Template]) -> dict[str, list[_Reached]]:
+    """The filters the render of each template reaches, in order (#284).
+
+    What a template reaches is the least set holding what it applies, its extends chain
+    put together (#285), and what each template it includes reaches, mapped through the
+    reference's bindings. The sets are computed
+    component by component, each after those its references reach, which are then
+    final. No cycle is cut: a template including itself with other bindings reaches what
+    Django renders at its next levels.
+
+    In a cycle, the names reaching the value and the argument of each filter application
+    are joined: one fact per application, whatever the paths that bring each name. The
+    analysis reads those names position by position, joining what each brings, so the
+    join loses nothing, and it keeps the facts few: bindings permuted around a cycle
+    would otherwise make one fact of every combination of names. In a component, every
+    template starts with no names and is recomputed from its references' facts; names
+    only join, and the applications and names of a project are finitely many, so the
+    names of an application grow at most once for each name. A template is recomputed
+    when a fact it reads grew, until none grows.
+
+    Once the facts are settled, a template outside any cycle lists what it applies,
+    then what each reference reaches, in order, first occurrences only, as a walk of
+    each path would. A template in a cycle has no such first occurrence, the cycle
+    having no start: it lists what it applies, then the rest by template, position,
+    function and names. The order thus depends only on the facts and the templates,
+    never on the order of the computation."""
+
+    renders = _renders(files, read)
+    reached: dict[str, list[_Reached]] = {}
+    for component in _components(renders):
+        single = component[0]
+        if len(component) == 1 and all(below != single for below, _ in renders[single].references):
+            # Outside any cycle: what its references reach is final.
+            found = dict.fromkeys(renders[single].applied)
+            for below, reference in renders[single].references:
+                found.update(dict.fromkeys(_mapped(reached[below], reference)))
+            reached[single] = list(found)
+            continue
+        members = set(component)
+        readers: dict[str, list[str]] = {member: [] for member in component}
+        for member in component:
+            for below, _ in renders[member].references:
+                if below in members:
+                    readers[below].append(member)
+        names: dict[str, dict[_Site, tuple[frozenset[str], frozenset[str]]]] = {member: {} for member in component}
+        sizes = dict.fromkeys(component, 0)
+        pending = deque(component)
+        queued = set(component)
+        while pending:
+            member = pending.popleft()
+            queued.discard(member)
+            grown: dict[_Site, tuple[frozenset[str], frozenset[str]]] = {}
+            _joined(renders[member].applied, grown)
+            for below, reference in renders[member].references:
+                below_found = _facts(names[below], names[below]) if below in members else reached[below]
+                _joined(_mapped(below_found, reference), grown)
+            # The names only join, so the count of applications and names only grows.
+            size = sum(1 + len(values) + len(arguments) for values, arguments in grown.values())
+            if size > sizes[member]:
+                names[member], sizes[member] = grown, size
+                for reader in readers[member]:
+                    if reader not in queued:
+                        pending.append(reader)
+                        queued.add(reader)
+        for member in component:
+            applied = _facts(names[member], dict.fromkeys((s, span, w) for s, span, w, _, _ in renders[member].applied))
+            sites = {(s, span, w) for s, span, w, _, _ in applied}
+            rest = _facts(names[member], (site for site in names[member] if site not in sites))
+            reached[member] = [*applied, *sorted(rest, key=_canonical)]
+    return reached
 
 
 def _read_scopes(text: str, source: SourceId, libraries: Mapping[str, _Library]) -> _Template:
@@ -1149,10 +1310,16 @@ def _read_scopes(text: str, source: SourceId, libraries: Mapping[str, _Library])
     opened: list[str] = []
     defined: set[str] = set()
     extended: set[str] = set()
+    enclosing: dict[str, str | None] = {}
     scopes: list[dict[str, frozenset[str]]] = [{}]
     blocks: list[tuple[list[tuple[str, int, frozenset[str]]], set[str]]] = []
     loaded: list[_Load] = []
     unresolved: dict[_Load, None] = {}
+    lines = LineIndex(text)
+
+    def span(offset: int) -> SourceSpan:
+        line, column = lines.position(offset)
+        return SourceSpan(source, line, column)
 
     def free(names: frozenset[str]) -> frozenset[str]:
         found: set[str] = set()
@@ -1192,9 +1359,7 @@ def _read_scopes(text: str, source: SourceId, libraries: Mapping[str, _Library])
             if isinstance(symbol, _Load):
                 unresolved[symbol] = None
             elif symbol is not None:
-                line, column = _position(text, offset)
-                span = SourceSpan(source, line, column)
-                applications.append(_Application(symbol, span, value, free(argument), tuple(opened)))
+                applications.append(_Application(symbol, span(offset), value, free(argument), tuple(opened)))
             value |= free(argument)
         return value
 
@@ -1234,6 +1399,7 @@ def _read_scopes(text: str, source: SourceId, libraries: Mapping[str, _Library])
             else:
                 values.setdefault(word, reached)
         if name == "block" and len(words) > 1:
+            enclosing.setdefault(words[1], opened[-1] if opened else None)
             opened.append(words[1])
             defined.add(words[1])
         elif name == "endblock" and opened:
@@ -1251,18 +1417,18 @@ def _read_scopes(text: str, source: SourceId, libraries: Mapping[str, _Library])
         elif name in ("include", "extends"):
             named = _constant(words[1]) if len(words) > 1 else None
             if name == "extends":
-                references.append(_Reference(named, offset, extends=True))
+                references.append(_Reference(named, span(offset), extends=True))
             else:
                 context = {k: v for scope in scopes for k, v in scope.items()}
-                references.append(_Reference(named, offset, bindings, "only" in words, context, tuple(opened)))
+                references.append(_Reference(named, span(offset), bindings, "only" in words, context, tuple(opened)))
         elif name == "load":
             selected = frozenset(words[1 : words.index("from")]) if "from" in words else None
-            loaded.extend(_Load(library, selected, offset) for library in _loaded(words[1:]))
+            loaded.extend(_Load(library, selected, span(offset)) for library in _loaded(words[1:]))
         elif "as" in words[1:-1]:
             target = words[words.index("as", 1) + 1]
             scopes[-1][target] = values.get(words[1], frozenset()) if name == "regroup" else frozenset()
     return _Template(
-        tuple(applications), tuple(references), frozenset(defined), frozenset(extended), tuple(unresolved)
+        tuple(applications), tuple(references), frozenset(defined), frozenset(extended), tuple(unresolved), enclosing
     )
 
 
@@ -1541,12 +1707,6 @@ def _expressions(text: str) -> Iterator[tuple[int, str, bool]]:
             yield match.start(2), tag, True
 
 
-def _position(text: str, offset: int) -> tuple[int, int]:
-    """The one-based line and column of ``offset`` in ``text``."""
-
-    return text.count("\n", 0, offset) + 1, offset - text.rfind("\n", 0, offset)
-
-
 class EscapedTemplates(Analysis[frozenset[str]]):
     """The names of the project templates that escape everything they render, provided
     by the engine for a project; none on its own."""

{coretrace_python_analyzer-0.24.0.dist-info → coretrace_python_analyzer-0.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: coretrace-python-analyzer
-Version: 0.24.0
+Version: 0.25.0
 Summary: Static security analysis infrastructure for Python code
 Project-URL: Homepage, https://github.com/CoreTrace/coretrace-python-analyzer
 Project-URL: Repository, https://github.com/CoreTrace/coretrace-python-analyzer

{coretrace_python_analyzer-0.24.0.dist-info → coretrace_python_analyzer-0.25.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-coretrace_python/__init__.py,sha256=HPlXBuD8AkmsMOeh3BStAk3r3TCd3EiqKpnm9R-yH6c,76
+coretrace_python/__init__.py,sha256=V3KQfEFIUS0wMCMwUjwFcE6mvYiqBT1my4ZjJcqpzEY,76
 coretrace_python/__main__.py,sha256=V8DnYtRboISK2VCKm7DGHLREKvqLbqApyWlKBOs26wU,65
 coretrace_python/cache.py,sha256=bFeK4apcvL4-XqASyqToiHiNZquFVM4dLjdDxUDXjTo,15556
 coretrace_python/cli.py,sha256=G9l03JpIqyjoRmDtwa2ZQZaDpeS4nX3pTzZtRRyBVfs,13972
@@ -143,20 +143,20 @@ coretrace_python/semantic/identity.py,sha256=uQBdqEXrOtYmGIiR9hZu0Pimv52iW1rOOOv
 coretrace_python/semantic/imports.py,sha256=389MZs8iTUc3CyUHG0VAgWFsypd7VPFKkLHmFz9L-N0,5673
 coretrace_python/semantic/scopes.py,sha256=vrFnEC1oX4UoAJHApY1fPH920ZEkGY0Htl8XMpQvSKk,22412
 coretrace_python/semantic/symbols.py,sha256=z0HQJyX2mlKGzMWzZAKgnUdNfzW2qu0oqv3dIZk4gpg,7454
-coretrace_python/source/__init__.py,sha256=Wi-w-_tNmiMUgmSoUMT7dbda_tjjfxpn91Fprq_VZTM,476
-coretrace_python/source/manager.py,sha256=DjTFVqAgROGmPbbQ3AV4zO8vYUA8rYy6OCPmMH-3hsY,5533
+coretrace_python/source/__init__.py,sha256=mwgLk_1n5K8LDRhj7AvNqcFr7_DGRJTZYXF1CeW8MPE,529
+coretrace_python/source/manager.py,sha256=1w9mGG8EDkX37lGw8l5pQnQICD9kYhLLpPZJTGRLkI8,6336
 coretrace_python/source/model.py,sha256=V9wa7wEzU1IWNf4DlSlFZiAcj_46dbOsBCMQPVU8lv4,2866
-coretrace_python/source/positions.py,sha256=GCUCuoTxyknY7cUo5SL2_QVYh9BDy_2u-22Hj9FsDhA,16603
+coretrace_python/source/positions.py,sha256=jb0ll5Sm9DCF7tk6ovY-KGLfPDV6h2WV7L0Z11Wbfu8,16038
 coretrace_python/taint/__init__.py,sha256=KPFK0SFGgohbGVVQDPSCkNXtdz9XUlfBuYko5QFYNh0,1915
 coretrace_python/taint/commands.py,sha256=HBQbSu0YfPQ1qlF8twWp2HQKKc1iOvBzkOVZTUFvakE,1787
 coretrace_python/taint/engine.py,sha256=43QQ-XrCTx4QiX1D2t8tqErxTlnaz11U2QSw486JCE0,58874
 coretrace_python/taint/models.py,sha256=EmnD6DyMznb2GZ0JYyW2D9PBm0I9Q9-mlkCB2PwZYt0,22432
 coretrace_python/taint/routes.py,sha256=UAJKXcw_sM9shf58FfDroxVO9bNSm4qrQdZknwUB0lo,6110
-coretrace_python/taint/templates.py,sha256=wRdUWLc-H6wL6OAokcGMw16vG87-ACgDYs-UxTK_GP8,72489
+coretrace_python/taint/templates.py,sha256=7D8AWWHsCoNg6WkYy3sMMEtHBC69yrWMh28QB-UkjOU,80631
 coretrace_python/taint/urls.py,sha256=kb0-uOT12ww7R3Jzs_lPKg9lFs74JI-bpa9pXX105xM,3166
-coretrace_python_analyzer-0.24.0.dist-info/METADATA,sha256=oWNxX_VeNHRGvxS8Xlu-yOA0y1C1HssKa2Fmh3eAnDk,3431
-coretrace_python_analyzer-0.24.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-coretrace_python_analyzer-0.24.0.dist-info/entry_points.txt,sha256=wdozemiraOkbt65g_Y_zgspuZpoLxJdaCVMJt1Ft3c0,72
-coretrace_python_analyzer-0.24.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-coretrace_python_analyzer-0.24.0.dist-info/licenses/NOTICE,sha256=s3VHj5ngV0ozjW_kZJpg_35ne6JwoBK0ysOjbqVtA0w,113
-coretrace_python_analyzer-0.24.0.dist-info/RECORD,,
+coretrace_python_analyzer-0.25.0.dist-info/METADATA,sha256=iVQGQatVaXcVVSRaOtGKBvtgyOqODZpHoKhUnGBfGdY,3431
+coretrace_python_analyzer-0.25.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+coretrace_python_analyzer-0.25.0.dist-info/entry_points.txt,sha256=wdozemiraOkbt65g_Y_zgspuZpoLxJdaCVMJt1Ft3c0,72
+coretrace_python_analyzer-0.25.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+coretrace_python_analyzer-0.25.0.dist-info/licenses/NOTICE,sha256=s3VHj5ngV0ozjW_kZJpg_35ne6JwoBK0ysOjbqVtA0w,113
+coretrace_python_analyzer-0.25.0.dist-info/RECORD,,

{coretrace_python_analyzer-0.24.0.dist-info → coretrace_python_analyzer-0.25.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.4
+Generator: hatchling 1.33.0
 Root-Is-Purelib: true
 Tag: py3-none-any