rbtr-lang-python 2026.9.0.dev1__tar.gz

rbtr_lang_python-2026.9.0.dev1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alejandro Giacometti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rbtr_lang_python-2026.9.0.dev1/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: rbtr-lang-python
+Version: 2026.9.0.dev1
+Summary: rbtr — Python language plugin
+Keywords: code-search,code-index,tree-sitter,static-analysis,semantic-search,developer-tools,python
+Author: Alejandro Giacometti
+Author-email: Alejandro Giacometti <alejandro.giacometti@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing :: Indexing
+Classifier: Typing :: Typed
+Requires-Dist: rbtr==2026.9.0.dev1
+Requires-Dist: tree-sitter-python
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/janrito/rbtr
+Project-URL: Repository, https://github.com/janrito/rbtr
+Project-URL: Documentation, https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-python#readme
+Project-URL: Issues, https://github.com/janrito/rbtr/issues
+Project-URL: Changelog, https://github.com/janrito/rbtr/releases
+Description-Content-Type: text/markdown
+
+# rbtr-lang-python
+
+Python support for [rbtr]. A **default** plugin — installed with rbtr
+itself (`pip install rbtr`).
+
+[rbtr]: https://github.com/janrito/rbtr/tree/main/packages/rbtr#readme
+
+## What it ingests
+
+- **Functions & methods** — `def` / `async def`; methods are scoped to their
+  enclosing class.
+- **Classes** — class definitions (which also form a scope for their members).
+- **Variables** — module-level assignments, including flat tuple unpacking.
+  Function locals and class attributes stay within their enclosing chunk.
+- **Imports** — `import` and `from … import` (relative, aliased, multi-name)
+  → import chunks with resolved module + names, for cross-file edges.
+
+A symbol's docstring (the leading `"""…"""`) is folded into its chunk content.
+
+## Chunks produced
+
+```python
+def greet(name): ...  # function "greet"
+
+
+class User:  # class "User"
+    def save(self): ...  #   method "save", scope "User"
+
+
+MAX = 100  # variable "MAX"
+from .utils import helper  # import, metadata {module: ".utils", names: "helper"}
+```
+
+## Embedded / injected chunks
+
+None of its own — Python is embedded *by* Markdown fenced code blocks, which
+delegate ` ```python ` blocks here.
+
+## Grammar & dependencies
+
+Uses the `tree-sitter-python` grammar. No dependency on other language plugins.

rbtr_lang_python-2026.9.0.dev1/README.md

@@ -0,0 +1,41 @@
+# rbtr-lang-python
+
+Python support for [rbtr]. A **default** plugin — installed with rbtr
+itself (`pip install rbtr`).
+
+[rbtr]: https://github.com/janrito/rbtr/tree/main/packages/rbtr#readme
+
+## What it ingests
+
+- **Functions & methods** — `def` / `async def`; methods are scoped to their
+  enclosing class.
+- **Classes** — class definitions (which also form a scope for their members).
+- **Variables** — module-level assignments, including flat tuple unpacking.
+  Function locals and class attributes stay within their enclosing chunk.
+- **Imports** — `import` and `from … import` (relative, aliased, multi-name)
+  → import chunks with resolved module + names, for cross-file edges.
+
+A symbol's docstring (the leading `"""…"""`) is folded into its chunk content.
+
+## Chunks produced
+
+```python
+def greet(name): ...  # function "greet"
+
+
+class User:  # class "User"
+    def save(self): ...  #   method "save", scope "User"
+
+
+MAX = 100  # variable "MAX"
+from .utils import helper  # import, metadata {module: ".utils", names: "helper"}
+```
+
+## Embedded / injected chunks
+
+None of its own — Python is embedded *by* Markdown fenced code blocks, which
+delegate ` ```python ` blocks here.
+
+## Grammar & dependencies
+
+Uses the `tree-sitter-python` grammar. No dependency on other language plugins.

rbtr_lang_python-2026.9.0.dev1/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["uv_build>=0.11.26,<1"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "rbtr_lang_python"
+
+[tool.uv.sources.rbtr]
+workspace = true
+
+[project]
+name = "rbtr-lang-python"
+version = "2026.9.0-dev1"
+description = "rbtr — Python language plugin"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "code-search",
+    "code-index",
+    "tree-sitter",
+    "static-analysis",
+    "semantic-search",
+    "developer-tools",
+    "python",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Text Processing :: Indexing",
+    "Typing :: Typed",
+]
+requires-python = ">=3.13"
+dependencies = [
+    "rbtr==2026.9.0-dev1",
+    "tree-sitter-python",
+]
+
+[[project.authors]]
+name = "Alejandro Giacometti"
+email = "alejandro.giacometti@gmail.com"
+
+[project.urls]
+Homepage = "https://github.com/janrito/rbtr"
+Repository = "https://github.com/janrito/rbtr"
+Documentation = "https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-python#readme"
+Issues = "https://github.com/janrito/rbtr/issues"
+Changelog = "https://github.com/janrito/rbtr/releases"
+
+[project.entry-points."rbtr.languages"]
+python = "rbtr_lang_python.plugin:python"
+
+[dependency-groups]
+dev = ["rbtr[test]"]

rbtr_lang_python-2026.9.0.dev1/pyproject.toml.orig

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["uv_build>=0.11.26,<1"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "rbtr_lang_python"
+# No source-exclude: the plugin's tests, samples, and snapshots ship
+# with the wheel (they are the language's golden record), and python.scm
+# ships as package data.
+
+[project]
+name = "rbtr-lang-python"
+version = "2026.9.0-dev1"
+description = "rbtr — Python language plugin"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "Alejandro Giacometti", email = "alejandro.giacometti@gmail.com" },
+]
+keywords = [
+  "code-search",
+  "code-index",
+  "tree-sitter",
+  "static-analysis",
+  "semantic-search",
+  "developer-tools",
+  "python",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: Text Processing :: Indexing",
+  "Typing :: Typed",
+]
+requires-python = ">=3.13"
+dependencies = [
+  "rbtr==2026.9.0-dev1",
+  "tree-sitter-python",
+]
+
+[project.urls]
+Homepage = "https://github.com/janrito/rbtr"
+Repository = "https://github.com/janrito/rbtr"
+Documentation = "https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-python#readme"
+Issues = "https://github.com/janrito/rbtr/issues"
+Changelog = "https://github.com/janrito/rbtr/releases"
+
+[project.entry-points."rbtr.languages"]
+# The value resolves to the language's `LanguageRegistration` (named by its
+# id) — see the rbtr ARCHITECTURE "External plugins" note.
+python = "rbtr_lang_python.plugin:python"
+
+[tool.uv.sources]
+rbtr = { workspace = true }
+
+[dependency-groups]
+dev = ["rbtr[test]"]

rbtr_lang_python-2026.9.0.dev1/src/rbtr_lang_python/__init__.py

@@ -0,0 +1 @@
+"""Python language plugin package."""

rbtr_lang_python-2026.9.0.dev1/src/rbtr_lang_python/plugin.py

@@ -0,0 +1,120 @@
+"""Python language plugin.
+
+Provides full support: symbol extraction (functions, classes,
+methods, imports) and structured import metadata.
+
+Extracted chunks::
+
+    def hello():            → function "hello", scope ""
+        pass
+
+    class Config:           → class "Config", scope ""
+        def load(self):     → method "load", scope "Config"
+            pass
+
+    import os               → import, metadata {module: "os"}
+    from pathlib import Path
+                            → import, metadata {module: "pathlib", names: "Path"}
+    from ..core import engine
+                            → import, metadata {dots: "2", module: "core",
+                                                names: "engine"}
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rbtr.domain.models import ImportMeta
+from rbtr.languages.registration import (
+    ImportResolver,
+    LanguageRegistration,
+    ModuleStyle,
+    QueryExtraction,
+    load_query,
+)
+
+if TYPE_CHECKING:
+    from tree_sitter import Node
+
+# ── Query ────────────────────────────────────────────────────────────
+
+# The `@_docstring` sub-capture marks the first-statement body
+# docstring for doc-range detection (used by `extract_doc_spans`
+# and the eval query sampler).  It is optional in the match
+# (`?`), so functions/classes without a docstring still match.
+
+# ── Import extractor ─────────────────────────────────────────────────
+
+
+def extract_import_meta(
+    resolver: ImportResolver, node: Node, captures: dict[str, list[Node]]
+) -> ImportMeta:
+    """Extract structured import data from a Python import node.
+
+    Reads query captures (`@_import_module`, `@_import_dots`)
+    and walks the node for multi-valued import names (which
+    the query can't capture).
+
+    Examples:
+
+        `import os.path`:
+            module="os.path"
+
+        `from pathlib import Path`:
+            module="pathlib", names="Path"
+
+        `from ..core import engine`:
+            dots="2", module="core", names="engine"
+
+        `from .models import Chunk as C`:
+            dots="1", module="models", names="Chunk"
+
+        `from . import utils`:
+            dots="1", names="utils"
+    """
+    meta = resolver(node, captures)
+
+    # Convert @_import_dots from raw import_prefix (e.g. "..")
+    # to a count string.
+    dots_nodes = captures.get("_import_dots", [])
+    if dots_nodes and dots_nodes[0].text:
+        meta.dots = str(dots_nodes[0].text.decode().count("."))
+
+    if node.type == "import_from_statement":
+        # Imported names.  The `name` field can be dotted_name
+        # or aliased_import; there may be multiple `name` fields.
+        names: list[str] = []
+        for name_node in node.children_by_field_name("name"):
+            match name_node.type:
+                case "dotted_name":
+                    if name_node.text:
+                        names.append(name_node.text.decode())
+                case "aliased_import":
+                    original = name_node.child_by_field_name("name")
+                    if original and original.text:
+                        names.append(original.text.decode())
+        if names:
+            meta.names = ",".join(names)
+
+    return meta
+
+
+# ── Plugin ───────────────────────────────────────────────────────────
+
+
+python = LanguageRegistration(
+    id="python",
+    extensions=frozenset({".py", ".pyi"}),
+    grammar_module="tree_sitter_python",
+    extraction=QueryExtraction(
+        query=load_query(__package__, "python"),
+        scope_types=frozenset({"class_definition", "function_definition"}),
+        class_scope_types=frozenset({"class_definition"}),
+    ),
+    index_files=frozenset({"__init__.py"}),
+    source_roots=("", "src"),
+    module_style=ModuleStyle.DOTTED,
+    extraction_serial=6,
+)
+
+python.import_extractor(extract_import_meta)

rbtr_lang_python-2026.9.0.dev1/src/rbtr_lang_python/python.scm

@@ -0,0 +1,68 @@
+; Comments and the module docstring. The engine groups comments into
+; blank-line-delimited blocks and either folds a block into the symbol flush
+; after it (its docstring, possibly nested), drops it if interior, or emits
+; it as a standalone COMMENT chunk.
+(comment) @comment
+(module (expression_statement (string) @comment))
+
+(function_definition
+  name: (identifier) @_fn_name
+  body: (block
+    . (expression_statement (string) @_docstring)?)) @function
+
+(class_definition
+  name: (identifier) @_cls_name
+  body: (block
+    . (expression_statement (string) @_docstring)?)) @class
+
+(type_alias_statement
+  . (type (identifier) @_cls_name)) @class
+
+(module
+  (expression_statement
+    (assignment
+      left: (identifier) @_var_name) @variable))
+
+(module
+  (expression_statement
+    (assignment
+      left: (pattern_list (identifier) @_var_name)) @variable))
+
+(module
+  (expression_statement
+    (assignment
+      left: (tuple_pattern (identifier) @_var_name)) @variable))
+
+(module
+  (expression_statement
+    (assignment
+      left: (list_pattern (identifier) @_var_name)) @variable))
+
+(module
+  (expression_statement
+    (assignment
+      left: (pattern_list (list_splat_pattern (identifier) @_var_name))) @variable))
+
+(import_statement
+  name: (dotted_name) @_import_module) @import
+
+; `import numpy as np` nests the module inside the alias.
+(import_statement
+  name: (aliased_import
+    name: (dotted_name) @_import_module)) @import
+
+(import_from_statement
+  module_name: (dotted_name) @_import_module) @import
+
+(import_from_statement
+  module_name: (relative_import
+    (import_prefix) @_import_dots
+    (dotted_name) @_import_module)) @import
+
+(import_from_statement
+  module_name: (relative_import
+    (import_prefix) @_import_dots .)) @import
+
+; `from __future__ import annotations` has its own node type, and is an
+; import like any other.
+(future_import_statement) @import

rbtr_lang_python-2026.9.0.dev1/src/rbtr_lang_python/tests/__snapshots__/test_samples/test_edges_match_snapshot.json

@@ -0,0 +1,3 @@
+[
+  "python.py::from .config import LOCALE -> config.py::LOCALE [imports]"
+]