[DeusData]

What

A package-relative from-import (from . import x, from .. import x, from . import x as y) has a
module spelled only with dots. extract_imports.c joined that module to the imported name with another
., so from . import x was recorded as ..x, which names the PARENT package. The import resolver
missed the real binding and fell to the symbol-name fallback in pass_pkgmap.c, which picks the
lexicographically first same-named definition anywhere in the project. That node became the import-map
value, and the Python LSP's alias binding consumes the same value. Every call through such an import
therefore became a confident import_map / lsp_callable_alias edge into an unrelated function.

Example (home-assistant): homeassistant/components/webhook/trigger.py does from . import async_register and calls it. The edge went to homeassistant.components.accuweather.system_health .async_register, the first of 28 functions with that name. Test packages were hit hardest:
tests/components/<integration>/test_*.py importing setup_integration / init_integration from their
own package bound to tests.components.acaia.*.

The fix joins without the extra separator when the module already ends in .. from .m import f
(recorded .m.f) and absolute imports are unchanged.

Evidence

Base origin/main 9f85f10 vs this head, 26 Python repos (manifest v1), production builds, macOS arm64,
--repeat 2, every repeat byte-identical.

	base	this PR	+added	-removed
CALLS	1,326,684	1,326,857	7,913	7,740
IMPORTS	477,476	481,037	5,666	2,105
TESTS	505,546	504,644	43	945
USAGE	1,654,225	1,654,569	2,204	1,860
WRITES	534,629	534,619	346	356
INHERITS / OVERRIDE	68,723 / 79,984	68,733 / 80,045	39 / 70	29 / 9

8 of 26 repos are identical; home-assistant carries most of the change (CALLS +7,402/-7,316).
Every changed stratum was sampled (12 edges each) and read:

• CALLS lsp_callable_alias +7,113/-5,829 and import_map +226/-1,394: every sampled removal pointed at
  the alphabetically first namesake (tests.components.acaia.*, ads.binary_sensor.setup_platform, a
  method of an unrelated class); the additions point at the importing package's own definition
  (11-12 of 12 correct; one plausible module alias).
• CALLS same_module -19: module-attribute calls through from . import X as alias bound to a same-named
  function of the caller's module; replaced by the correct import_map edges.
• IMPORTS: removals were the wrong namesakes (and from . import util as orm_util in sqlalchemy's orm
  bound to the parent package's util); additions name the right package member or module.
• TESTS -945: test->production edges that existed only because a test's own helper was mis-bound to a
  production function of another integration.
• USAGE / WRITES / DECORATES churn (mostly sqlalchemy, net flat): attribute reads and writes on untyped
  receivers are resolved by name guesses ranked by import reachability; with sqlalchemy's relative imports
  now resolving, those guesses re-rank. Neither side is a reliable target.
• Recall oracle (stdlib ast over every corpus file, 26 repos; each expected caller/callee pair checked
  against the graph): bare calls through relative from-imports 23,217 / 30,405 correct (76.4%, 7,179
  wrong) -> 30,396 / 30,405 (99.97%, 0 wrong); aliased relative 89 / 93 -> 93 / 93; module-attribute calls
  +115 correct. Absolute from-imports, re-exports and same-file calls are unchanged (the fix touches only
  the relative forms).

Exposed regressions (17 edges plus derived OVERRIDE)

These are pre-existing approximations that the corrected imports now reach:

• 16 INHERITS (sqlalchemy 15, matplotlib 1) plus their derived OVERRIDE edges: exception classes nested in
  AsyncAdapt_asyncpg_dbapi (class OperationalError(DatabaseError) names the SIBLING nested class) now
  resolve to lib.sqlalchemy.exc.DatabaseError. A bare base name is resolved through the registry's name
  strategies, which prefer an import-reachable candidate; the sibling won only while exc was not
  reachable. Closed by fix(python): bind a nested class base to an earlier sibling of its class body #2695, which resolves a nested class's bare base in its enclosing class body first
  (exact). Measured with this change: all 16 come back.
• 1 super() call (home-assistant radarr): RadarrCalendarEntity(RadarrEntity, CalendarEntity)'s
  super()._async_write_ha_state() moved from CalendarEntity (C3 order) to Entity: the super()
  lookup walks each base's ancestry depth-first; resolving RadarrEntity's ancestry exposed it. Closed by
  fix(python-lsp): resolve super() through the C3 method resolution order #2696, which walks the C3 MRO.
• Re-export suffix picks: @testing.combinations and sql.cast / sql.select / sql.and_ now land on a
  same-named method inside the correctly resolved package instead of the re-exported function (the
  package __init__ re-exports it). Closed by the re-export resolution work in a follow-up PR, which lists these
  as required cases.

Re-measured on current main (clean builds)

The numbers above were measured against main 9f85f10. This change merged with main ea5c1f7 was rebuilt
from a clean build directory and compared with a clean ea5c1f7 build on sqlalchemy and matplotlib
(--repeat 2, noise 0):

• IMPORTS, INHERITS, OVERRIDE and DECORATES are identical to the figures above on both repos. matplotlib's
  USAGE, WRITES and TESTS are identical too.
• sqlalchemy CALLS is +310 / -286 (was +296 / -273). USAGE is +1,358 / -1,280 (was +1,338 / -1,261) and
  WRITES +284 / -280 (was +281 / -277), TESTS +15 / -14 (was +15 / -15). matplotlib CALLS is +63 / -24
  (was +62 / -24).
• The difference comes from fix(python): extract defs nested in a function body and resolve bare names lexically (#1548) #2686 (defs nested in functions), which landed in between. The same corrected
  calls now start at the nested def instead of the file node (collections._dict_decorators.setdefault
  instead of collections.py), and the newly extracted nested defs add a few more calls through the
  corrected imports. The targets are unchanged.

Tests

• python_package_relative_import_paths (extraction): the recorded paths for all three forms, plus
  .m.f and absolute controls.
• pipeline_python_package_relative_imports and ..._parallel: each form resolves to the own or parent
  package, never to the same-named function that sorts first, and not through a name guess; both
  resolvers. RED with the extractor change reverted ("..async_register" != ".async_register";
  own == 0), GREEN here.
• pipeline_python_from_import_bare_call_issue1237 and ..._parallel (guard for trace_path/callers returns empty for plain "from module import func" + bare call across files (Python) #1237): a plain
  from pkg.db import get_row_or_none plus bare calls from a function, a method and the same file bind
  the imported def, never a same-named def elsewhere; a re-index that only adds a file leaves CALLS
  unchanged. Main already resolves this shape, so this guard has no RED on revert.
• Affected suites (complexity, extraction, registry, pipeline, cross_repo, py_lsp,
  lsp_resolution_probe, incremental): 1,323 passed on the tree merged with main.

Notes

• No index-format change. Indexes built before this change keep the old import paths until the affected
  files are extracted again.
• Refs trace_path/callers returns empty for plain "from module import func" + bare call across files (Python) #1237 (stays open until the related import-resolution work lands).