Method extract_assignment

atomic-semantic/src/parsers/python.rs:211–253

Extract a module-level assignment (`X = 42` or `X: int = 42`).

(&self, node: &Node, source: &str, file_path: &str)

    /// Extract a module-level assignment (`X = 42` or `X: int = 42`).
    fn extract_assignment(&self, node: &Node, source: &str, file_path: &str) -> Option<Entity> {
        // Get the left side of the assignment
        let left = node.child_by_field_name("left")?;

        // Only extract simple name assignments, not tuple/attribute assignments
        if left.kind() != "identifier" {
            return None;
        }

        let name = self.node_text(&left, source);

        // Skip private variables
        if name.starts_with('_') && !name.starts_with("__") {
            return None;
        }

        // Skip common non-semantic assignments
        if name == "logger" || name == "log" {
            return None;
        }

        let line = node.start_position().row as u32 + 1;
        let end_line = node.end_position().row as u32 + 1;

        // Check if it's ALL_CAPS (constant-like)
        let is_const = name.chars().all(|c| c.is_uppercase() || c == '_');
        let kind = if is_const {
            EntityKind::Const
        } else {
            EntityKind::Variable
        };

        let exported = !name.starts_with('_');
        let sig = self.node_text(node, source);

        let mut entity = Entity::new(name, kind, file_path, line, end_line);
        entity = entity.with_signature(sig);
        if exported {
            entity.exported = true;
        }

        Some(entity)
    }

    /// Extract an import statement.
    fn extract_import(&self, node: &Node, source: &str, file_path: &str) -> Option<Entity> {