osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/python/django_models.py

@@ -0,0 +1,157 @@
+"""Django model detector."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class DjangoModelDetector:
+    """Detects Django model, manager, and relationship definitions."""
+
+    name: str = "python.django_models"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    _DJANGO_MODEL_RE = re.compile(
+        r"^class\s+(\w+)\s*\(\s*[\w.]*Model\s*\)", re.MULTILINE
+    )
+    _FK_RE = re.compile(
+        r"(\w+)\s*=\s*models\.(?:ForeignKey|OneToOneField)\s*\(\s*[\"']?(\w+)",
+        re.MULTILINE,
+    )
+    _M2M_RE = re.compile(
+        r"(\w+)\s*=\s*models\.ManyToManyField\s*\(\s*[\"']?(\w+)", re.MULTILINE
+    )
+    _FIELD_RE = re.compile(r"(\w+)\s*=\s*models\.(\w+Field)\s*\(", re.MULTILINE)
+    _META_TABLE_RE = re.compile(r"db_table\s*=\s*[\"'](\w+)[\"']")
+    _META_ORDERING_RE = re.compile(r"ordering\s*=\s*(\[.*?\])")
+    _MANAGER_RE = re.compile(
+        r"^class\s+(\w+)\s*\(\s*[\w.]*Manager\s*\)", re.MULTILINE
+    )
+    _MANAGER_ASSIGNMENT_RE = re.compile(r"(\w+)\s*=\s*(\w+)\s*\(\s*\)", re.MULTILINE)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Detect managers first so we can link them
+        manager_names: dict[str, str] = {}
+        for match in self._MANAGER_RE.finditer(text):
+            mgr_name = match.group(1)
+            line = text[: match.start()].count("\n") + 1
+            node_id = f"django:{ctx.file_path}:manager:{mgr_name}"
+            manager_names[mgr_name] = node_id
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.REPOSITORY,
+                    label=mgr_name,
+                    fqn=f"{ctx.file_path}::{mgr_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={"framework": "django", "type": "manager"},
+                )
+            )
+
+        # Detect models
+        for match in self._DJANGO_MODEL_RE.finditer(text):
+            class_name = match.group(1)
+            line = text[: match.start()].count("\n") + 1
+
+            # Determine class body boundaries
+            class_start = match.start()
+            next_class = re.search(r"\nclass\s+\w+", text[match.end() :])
+            class_body = (
+                text[class_start : match.end() + next_class.start()]
+                if next_class
+                else text[class_start:]
+            )
+
+            # Extract fields
+            fields: dict[str, str] = {}
+            for fm in self._FIELD_RE.finditer(class_body):
+                fields[fm.group(1)] = fm.group(2)
+
+            # Extract Meta properties
+            table_name: str | None = None
+            ordering: str | None = None
+            meta_match = re.search(r"class\s+Meta\s*:", class_body)
+            if meta_match:
+                meta_start = meta_match.end()
+                meta_end = len(class_body)
+                for cm in re.finditer(r"\n\s{4}\S", class_body[meta_start:]):
+                    meta_end = meta_start + cm.start()
+                    break
+                meta_block = class_body[meta_start:meta_end]
+                table_match = self._META_TABLE_RE.search(meta_block)
+                if table_match:
+                    table_name = table_match.group(1)
+                ordering_match = self._META_ORDERING_RE.search(meta_block)
+                if ordering_match:
+                    ordering = ordering_match.group(1)
+
+            node_id = f"django:{ctx.file_path}:model:{class_name}"
+            props: dict = {
+                "fields": fields,
+                "framework": "django",
+            }
+            if table_name:
+                props["table_name"] = table_name
+            if ordering:
+                props["ordering"] = ordering
+
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENTITY,
+                    label=class_name,
+                    fqn=f"{ctx.file_path}::{class_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties=props,
+                )
+            )
+
+            # FK / OneToOne edges
+            for fk in self._FK_RE.finditer(class_body):
+                target = fk.group(2)
+                target_id = f"django:{ctx.file_path}:model:{target}"
+                result.edges.append(
+                    GraphEdge(
+                        source=node_id,
+                        target=target_id,
+                        kind=EdgeKind.DEPENDS_ON,
+                        label=fk.group(1),
+                    )
+                )
+
+            # M2M edges
+            for m2m in self._M2M_RE.finditer(class_body):
+                target = m2m.group(2)
+                target_id = f"django:{ctx.file_path}:model:{target}"
+                result.edges.append(
+                    GraphEdge(
+                        source=node_id,
+                        target=target_id,
+                        kind=EdgeKind.DEPENDS_ON,
+                        label=m2m.group(1),
+                    )
+                )
+
+            # Manager assignments (objects = MyManager())
+            for ma in self._MANAGER_ASSIGNMENT_RE.finditer(class_body):
+                mgr_class = ma.group(2)
+                if mgr_class in manager_names:
+                    result.edges.append(
+                        GraphEdge(
+                            source=node_id,
+                            target=manager_names[mgr_class],
+                            kind=EdgeKind.QUERIES,
+                            label=ma.group(1),
+                        )
+                    )
+
+        return result

osscodeiq/detectors/python/django_views.py

@@ -0,0 +1,74 @@
+"""Django URL pattern and view detector."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class DjangoViewDetector:
+    """Detects Django URL patterns, class-based views, and function views."""
+
+    name: str = "python.django_views"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    # urlpatterns entries: path('api/users/', UserView.as_view(), name='user-list')
+    _URL_PATTERN = re.compile(
+        r"(?:path|re_path|url)\(\s*['\"]([^'\"]+)['\"]"
+        r"\s*,\s*(\w[\w.]*)"
+    )
+
+    # Class-based views: class UserView(APIView): or class UserViewSet(ModelViewSet):
+    _CBV_PATTERN = re.compile(
+        r"class\s+(\w+)\(([^)]*(?:View|ViewSet|Mixin)[^)]*)\):"
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Detect URL patterns (typically in urls.py)
+        if "urlpatterns" in text:
+            for match in self._URL_PATTERN.finditer(text):
+                path_pattern = match.group(1)
+                view_ref = match.group(2)
+                line = text[:match.start()].count("\n") + 1
+
+                node_id = f"endpoint:{ctx.module_name or ''}:ALL:{path_pattern}"
+                result.nodes.append(GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"{path_pattern}",
+                    fqn=view_ref,
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "protocol": "REST",
+                        "path_pattern": path_pattern,
+                        "framework": "django",
+                        "view_reference": view_ref,
+                    },
+                ))
+
+        # Detect class-based views
+        for match in self._CBV_PATTERN.finditer(text):
+            class_name = match.group(1)
+            bases = match.group(2)
+            line = text[:match.start()].count("\n") + 1
+
+            node_id = f"class:{ctx.file_path}::{class_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.CLASS,
+                label=class_name,
+                fqn=f"{ctx.file_path}::{class_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=[f"extends:{bases.strip()}"],
+                properties={"framework": "django", "stereotype": "view"},
+            ))
+
+        return result

osscodeiq/detectors/python/fastapi_auth.py

@@ -0,0 +1,143 @@
+"""FastAPI authentication and authorization detector for Python source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import GraphNode, NodeKind, SourceLocation
+
+# Depends(get_current_user) or Depends(get_current_active_user) etc.
+_DEPENDS_AUTH_RE = re.compile(
+    r'Depends\(\s*(get_current[\w]*|require_auth[\w]*|auth[\w]*)\s*\)'
+)
+
+# Security(oauth2_scheme) or Security(some_auth_scheme, scopes=[...])
+_SECURITY_RE = re.compile(
+    r'Security\(\s*(\w+)'
+)
+
+# HTTPBearer() instantiation
+_HTTP_BEARER_RE = re.compile(
+    r'HTTPBearer\s*\('
+)
+
+# OAuth2PasswordBearer(tokenUrl=...) instantiation
+_OAUTH2_PASSWORD_BEARER_RE = re.compile(
+    r'OAuth2PasswordBearer\s*\(\s*tokenUrl\s*=\s*["\']([^"\']*)["\']'
+)
+
+# HTTPBasic() instantiation
+_HTTP_BASIC_RE = re.compile(
+    r'HTTPBasic\s*\('
+)
+
+
+def _line_number(text: str, pos: int) -> int:
+    """Return 1-based line number for a character offset."""
+    return text[:pos].count("\n") + 1
+
+
+class FastAPIAuthDetector:
+    """Detects FastAPI auth patterns in Python source files."""
+
+    name: str = "fastapi_auth"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Depends(get_current_user) and similar auth dependencies
+        for m in _DEPENDS_AUTH_RE.finditer(text):
+            line = _line_number(text, m.start())
+            dep_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"auth:{ctx.file_path}:Depends:{line}",
+                kind=NodeKind.GUARD,
+                label=f"Depends({dep_name})",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=[f"Depends({dep_name})"],
+                properties={
+                    "auth_type": "fastapi",
+                    "auth_flow": "oauth2",
+                    "dependency": dep_name,
+                    "auth_required": True,
+                },
+            ))
+
+        # Security(scheme) calls
+        for m in _SECURITY_RE.finditer(text):
+            line = _line_number(text, m.start())
+            scheme_name = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"auth:{ctx.file_path}:Security:{line}",
+                kind=NodeKind.GUARD,
+                label=f"Security({scheme_name})",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=[f"Security({scheme_name})"],
+                properties={
+                    "auth_type": "fastapi",
+                    "auth_flow": "oauth2",
+                    "scheme": scheme_name,
+                    "auth_required": True,
+                },
+            ))
+
+        # HTTPBearer() instantiations
+        for m in _HTTP_BEARER_RE.finditer(text):
+            line = _line_number(text, m.start())
+            result.nodes.append(GraphNode(
+                id=f"auth:{ctx.file_path}:HTTPBearer:{line}",
+                kind=NodeKind.GUARD,
+                label="HTTPBearer()",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=["HTTPBearer"],
+                properties={
+                    "auth_type": "fastapi",
+                    "auth_flow": "bearer",
+                    "auth_required": True,
+                },
+            ))
+
+        # OAuth2PasswordBearer(tokenUrl=...) instantiations
+        for m in _OAUTH2_PASSWORD_BEARER_RE.finditer(text):
+            line = _line_number(text, m.start())
+            token_url = m.group(1)
+            result.nodes.append(GraphNode(
+                id=f"auth:{ctx.file_path}:OAuth2PasswordBearer:{line}",
+                kind=NodeKind.GUARD,
+                label=f"OAuth2PasswordBearer({token_url})",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=["OAuth2PasswordBearer"],
+                properties={
+                    "auth_type": "fastapi",
+                    "auth_flow": "oauth2",
+                    "token_url": token_url,
+                    "auth_required": True,
+                },
+            ))
+
+        # HTTPBasic() instantiations
+        for m in _HTTP_BASIC_RE.finditer(text):
+            line = _line_number(text, m.start())
+            result.nodes.append(GraphNode(
+                id=f"auth:{ctx.file_path}:HTTPBasic:{line}",
+                kind=NodeKind.GUARD,
+                label="HTTPBasic()",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                annotations=["HTTPBasic"],
+                properties={
+                    "auth_type": "fastapi",
+                    "auth_flow": "basic",
+                    "auth_required": True,
+                },
+            ))
+
+        return result

osscodeiq/detectors/python/fastapi_routes.py

@@ -0,0 +1,68 @@
+"""FastAPI route detector."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class FastAPIRouteDetector:
+    """Detects FastAPI route decorators (@app.get, @router.post, etc.)."""
+
+    name: str = "python.fastapi_routes"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    _ROUTE_PATTERN = re.compile(
+        r"@(\w+)\.(get|post|put|delete|patch|options|head)\(\s*['\"]([^'\"]+)['\"]"
+        r".*?\)\s*\n(?:\s*async\s+)?def\s+(\w+)",
+        re.DOTALL,
+    )
+
+    # APIRouter prefix: router = APIRouter(prefix="/api/v1/users")
+    _ROUTER_PREFIX = re.compile(
+        r"(\w+)\s*=\s*APIRouter\(.*?prefix\s*=\s*['\"]([^'\"]+)['\"]",
+        re.DOTALL,
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Extract router prefixes
+        prefixes: dict[str, str] = {}
+        for match in self._ROUTER_PREFIX.finditer(text):
+            prefixes[match.group(1)] = match.group(2)
+
+        for match in self._ROUTE_PATTERN.finditer(text):
+            router_name = match.group(1)
+            method = match.group(2).upper()
+            path = match.group(3)
+            func_name = match.group(4)
+
+            # Prepend router prefix if known
+            prefix = prefixes.get(router_name, "")
+            full_path = prefix + path
+
+            line = text[:match.start()].count("\n") + 1
+
+            node_id = f"endpoint:{ctx.module_name or ''}:{method}:{full_path}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.ENDPOINT,
+                label=f"{method} {full_path}",
+                fqn=f"{ctx.file_path}::{func_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "protocol": "REST",
+                    "http_method": method,
+                    "path_pattern": full_path,
+                    "framework": "fastapi",
+                    "router": router_name,
+                },
+            ))
+
+        return result

osscodeiq/detectors/python/flask_routes.py

@@ -0,0 +1,67 @@
+"""Flask route detector."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class FlaskRouteDetector:
+    """Detects Flask route decorators (@app.route, @blueprint.route)."""
+
+    name: str = "python.flask_routes"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    # Matches @app.route('/path', methods=['GET', 'POST']) and @blueprint.route(...)
+    _ROUTE_PATTERN = re.compile(
+        r"@(\w+)\.(route)\(\s*['\"]([^'\"]+)['\"]"
+        r"(?:.*?methods\s*=\s*\[([^\]]+)\])?"
+        r".*?\)\s*\n\s*def\s+(\w+)",
+        re.DOTALL,
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        for match in self._ROUTE_PATTERN.finditer(text):
+            blueprint = match.group(1)
+            path = match.group(3)
+            methods_raw = match.group(4)
+            func_name = match.group(5)
+
+            methods = ["GET"]
+            if methods_raw:
+                methods = [m.strip().strip("'\"") for m in methods_raw.split(",")]
+
+            line = text[:match.start()].count("\n") + 1
+
+            for method in methods:
+                node_id = f"endpoint:{ctx.module_name or ''}:{method}:{path}"
+                result.nodes.append(GraphNode(
+                    id=node_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"{method} {path}",
+                    fqn=f"{ctx.file_path}::{func_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    properties={
+                        "protocol": "REST",
+                        "http_method": method,
+                        "path_pattern": path,
+                        "framework": "flask",
+                        "blueprint": blueprint,
+                    },
+                ))
+
+                class_id = f"class:{ctx.file_path}::{blueprint}"
+                result.edges.append(GraphEdge(
+                    source=class_id,
+                    target=node_id,
+                    kind=EdgeKind.EXPOSES,
+                ))
+
+        return result

osscodeiq/detectors/python/kafka_python.py

@@ -0,0 +1,175 @@
+"""Kafka producer/consumer detector for Python source files.
+
+Detects usage of confluent-kafka, aiokafka, and kafka-python libraries.
+"""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+# Producer instantiation patterns
+_PRODUCER_RE = re.compile(
+    r"(KafkaProducer|AIOKafkaProducer)\s*\(", re.MULTILINE
+)
+_CONFLUENT_PRODUCER_RE = re.compile(
+    r"Producer\s*\(\s*\{", re.MULTILINE
+)
+
+# Consumer instantiation patterns
+_CONSUMER_RE = re.compile(
+    r"(KafkaConsumer|AIOKafkaConsumer)\s*\(", re.MULTILINE
+)
+_CONFLUENT_CONSUMER_RE = re.compile(
+    r"Consumer\s*\(\s*\{", re.MULTILINE
+)
+
+# Topic send/produce patterns
+_SEND_RE = re.compile(
+    r"\.send\s*\(\s*['\"]([^'\"]+)['\"]", re.MULTILINE
+)
+_PRODUCE_RE = re.compile(
+    r"\.produce\s*\(\s*['\"]([^'\"]+)['\"]", re.MULTILINE
+)
+
+# Subscribe pattern
+_SUBSCRIBE_RE = re.compile(
+    r"\.subscribe\s*\(\s*\[\s*['\"]([^'\"]+)['\"]", re.MULTILINE
+)
+
+# Import patterns
+_IMPORT_RE = re.compile(
+    r"(?:from|import)\s+(confluent_kafka|kafka|aiokafka)\b", re.MULTILINE
+)
+
+
+class KafkaPythonDetector:
+    """Detects Kafka usage in Python via confluent-kafka, aiokafka, and kafka-python."""
+
+    name: str = "kafka_python"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+        fp = ctx.file_path
+
+        # Quick bail-out: check for any Kafka-related keyword
+        if not any(kw in text for kw in (
+            "KafkaProducer", "KafkaConsumer",
+            "AIOKafkaProducer", "AIOKafkaConsumer",
+            "confluent_kafka", "from kafka",
+            "import kafka", "Producer(", "Consumer(",
+        )):
+            return result
+
+        seen_topics: set[str] = set()
+
+        def _ensure_topic(topic: str, role: str, line: int) -> str:
+            topic_id = f"kafka_py:{fp}:topic:{topic}"
+            if topic not in seen_topics:
+                seen_topics.add(topic)
+                result.nodes.append(GraphNode(
+                    id=topic_id,
+                    kind=NodeKind.TOPIC,
+                    label=f"kafka:{topic}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp, line_start=line),
+                    properties={"broker": "kafka", "topic": topic, "role": role},
+                ))
+            return topic_id
+
+        file_node_id = f"kafka_py:{fp}"
+
+        # Detect producer instantiations
+        for i, line in enumerate(lines):
+            lineno = i + 1
+            if _PRODUCER_RE.search(line) or _CONFLUENT_PRODUCER_RE.search(line):
+                result.nodes.append(GraphNode(
+                    id=f"kafka_py:{fp}:producer:{lineno}",
+                    kind=NodeKind.TOPIC,
+                    label="kafka:producer",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp, line_start=lineno),
+                    properties={"role": "producer"},
+                ))
+
+        # Detect consumer instantiations
+        for i, line in enumerate(lines):
+            lineno = i + 1
+            if _CONSUMER_RE.search(line) or _CONFLUENT_CONSUMER_RE.search(line):
+                result.nodes.append(GraphNode(
+                    id=f"kafka_py:{fp}:consumer:{lineno}",
+                    kind=NodeKind.TOPIC,
+                    label="kafka:consumer",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=fp, line_start=lineno),
+                    properties={"role": "consumer"},
+                ))
+
+        # Detect producer.send / producer.produce -> PRODUCES edges
+        for i, line in enumerate(lines):
+            lineno = i + 1
+            m = _SEND_RE.search(line)
+            if m and ("send" in line):
+                topic = m.group(1)
+                topic_id = _ensure_topic(topic, "producer", lineno)
+                result.edges.append(GraphEdge(
+                    source=file_node_id,
+                    target=topic_id,
+                    kind=EdgeKind.PRODUCES,
+                    label=f"produces to {topic}",
+                    properties={"topic": topic},
+                ))
+                continue
+            m = _PRODUCE_RE.search(line)
+            if m:
+                topic = m.group(1)
+                topic_id = _ensure_topic(topic, "producer", lineno)
+                result.edges.append(GraphEdge(
+                    source=file_node_id,
+                    target=topic_id,
+                    kind=EdgeKind.PRODUCES,
+                    label=f"produces to {topic}",
+                    properties={"topic": topic},
+                ))
+
+        # Detect consumer.subscribe -> CONSUMES edges
+        for i, line in enumerate(lines):
+            lineno = i + 1
+            m = _SUBSCRIBE_RE.search(line)
+            if m:
+                topic = m.group(1)
+                topic_id = _ensure_topic(topic, "consumer", lineno)
+                result.edges.append(GraphEdge(
+                    source=file_node_id,
+                    target=topic_id,
+                    kind=EdgeKind.CONSUMES,
+                    label=f"consumes from {topic}",
+                    properties={"topic": topic},
+                ))
+
+        # Detect imports -> IMPORTS edges
+        for i, line in enumerate(lines):
+            m = _IMPORT_RE.search(line)
+            if m:
+                lib = m.group(1)
+                result.edges.append(GraphEdge(
+                    source=file_node_id,
+                    target=f"kafka_py:lib:{lib}",
+                    kind=EdgeKind.IMPORTS,
+                    label=f"imports {lib}",
+                    properties={"library": lib},
+                ))
+
+        return result