FilesExpand file tree

lua

/

python.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

53 lines (52 loc) · 1.83 KB

lua

/

python.ts

Copy path

Top

File metadata and controls

• Code
• Blame

53 lines (52 loc) · 1.83 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

import { getNodeText, getChildByField } from '../tree-sitter-helpers';

import type { LanguageExtractor } from '../tree-sitter-types';

export const pythonExtractor: LanguageExtractor = {

functionTypes: ['function_definition'],

classTypes: ['class_definition'],

methodTypes: ['function_definition'], // Methods are functions inside classes

interfaceTypes: [],

structTypes: [],

enumTypes: [],

typeAliasTypes: [],

importTypes: ['import_statement', 'import_from_statement'],

callTypes: ['call'],

variableTypes: ['assignment'], // Python uses assignment for variable declarations

nameField: 'name',

bodyField: 'body',

paramsField: 'parameters',

returnField: 'return_type',

getSignature: (node, source) => {

const params = getChildByField(node, 'parameters');

const returnType = getChildByField(node, 'return_type');

if (!params) return undefined;

let sig = getNodeText(params, source);

if (returnType) {

sig += ' -> ' + getNodeText(returnType, source);

}

return sig;

},

isAsync: (node) => {

const prev = node.previousSibling;

return prev?.type === 'async';

},

isStatic: (node) => {

// Check for @staticmethod decorator

const prev = node.previousNamedSibling;

if (prev?.type === 'decorator') {

const text = prev.text;

return text.includes('staticmethod');

}

return false;

},

extractImport: (node, source) => {

const importText = source.substring(node.startIndex, node.endIndex).trim();

if (node.type === 'import_from_statement') {

const moduleNode = node.childForFieldName('module_name');

if (moduleNode) {

return { moduleName: source.substring(moduleNode.startIndex, moduleNode.endIndex), signature: importText };

}

}

// import_statement creates multiple imports - return null for core fallback

return null;

},

};