srcML v1.0.0 Python Documentation

Base Elements	XML Element	Subelements
comment	<comment type="line\|hashbang">
literal	<literal type="boolean\|complex\|ellipsis\|null\|number\|string">
escape	<escape char="0xXX">
name	<name>

Statements	XML Element	Subelements
argument parameter	<parameter type="args">	<annotation>,<expr>
assert statement	<assert>	<condition>
block	<block>	<block_content>
break statement	<break>
case statement	<case>	<expr>,<block>,<alias>,<condition>
continue statement	<continue>
delete	<delete>	<name>
execute statement	<exec>	<expr>
expression statement	<expr_stmt>	<expr>
for statement	<for>	<control>,<block>,<specifier>,<else>
global statement	<global>	<name>
if statement	<if_stmt>	<if>,<if type="elseif">,<else>
import statement	<import>	<from>,<name>,<alias>
keyword argument parameter	<parameter type="kwargs">	<annotation>,<expr>
nonlocal	<nonlocal>	<name>
parameter	<parameter>	<annotation>,<expr>,<init>
parameter modifiers	<parameter type="modifier">
pass statement	<pass>
print statement	<print>	<expr>
return statement	<return>	<expr>
switch statement	<switch>	<condition>,<block>
while statement	<while>	<condition>,<block>,<else>
with statement	<with>	<specifier>,<alias>,<block>,<expr>
yield from statement	<yield type="from">	<expr>
yield statement	<yield>	<expr>

Statement Subelements	XML Element	Subelements
alias	<alias>
annotation	<annotation>
block content	<block_content>
condition	<condition>	<expr>
control	<control>	<init>,<condition>
else	<else>	<block>
else if	<if type="elseif">	<condition>,<block>
expr	<expr>
if	<if>	<condition>,<block>
super class	<super>

Specifiers	XML Element	Subelements
async specifier	<specifier>async</specifier>

Declarations, Definitions, and Initializations	XML Element	Subelements
declaration initialization	<init>
function	<function>	<annotation>,<name>,<parameter_list>,<parameter_list type="generic">,<block>,<attribute>,<specifier>
lambda functions	<lambda>	<parameter>,<expr>
range	<range>	<expr>
typedef	<typedef>	<name>,<expr>

Classes, Structs, Unions, and Enums	XML Element	Subelements
class definition	<class>	<name>,<attribute>,<super_list>,<parameter_list type="generic">,<block>
inheritance list	<super_list>	<super>,<expr>

Expressions	XML Element	Subelements
argument	<argument>	<name>,<expr>
argument list	<argument_list>	<argument>
comprehension	<comprehension>	<for>,<specifier>,<control>,<range>,<if>
dictionary	<dictionary>	<expr>,<comprehension>
function call	<call>	<name>,<argument_list>
index	<index>	<expr>
list	<array>	<expr>,<comprehension>
operator	<operator>
set	<set>	<expr>,<comprehension>
ternary operator	<ternary>	<condition>,<else>
tuple	<tuple>	<expr>

Other	XML Element	Subelements
attribute	<attribute>	<expr>

Templates	XML Element	Subelements
generic property	<parameter_list type="generic">	<parameter>
parameter list	<parameter_list>	<parameter>

Exceptions	XML Element	Subelements
except statement	<catch>	<alias>,<expr>,<block>,<name>
finally	<finally>	<block>
throw	<throw>	<expr>,<from>
try	<try>	<block>,<catch>,<else>,<finally>

line comment

Element

<comment type="line">

XPath

srcQL

comments
```
//src:comment
```
line comments
```
//src:comment[@type='line']
```

find any line comment
```
FIND src:comment[@type="line"]
```

Example

# line

<comment type="line"># line</comment>

hashbang comment

Element

<comment type="hashbang">

XPath

srcQL

comments
```
//src:comment
```
hashbang comments
```
//src:comment[@type='hashbang']
```

find any hashbang comment
```
FIND src:comment[@type="hashbang"]
```

Example

#!/usr/bin/python3

<comment type="hashbang">#!/usr/bin/python3</comment>

escape

Element

<escape char="0xXX">

Example


def process():
    pass

<escape char="0x0c"/>
<function>def <name>process</name><parameter_list>()</parameter_list><block>:<block_content>
    <pass>pass</pass></block_content></block></function>

number literal

Element

<literal type="number">123</literal>

XPath

srcQL

number literals
```
//src:literal[@type='number']
```
abstract function declarations
```
//src:function_decl[src:literal=0]
```

find any number literal
```
FIND src:literal[@type="number"]
```

Example

123
42.0

<expr_stmt><expr><literal type="number">123</literal></expr></expr_stmt>
<expr_stmt><expr><literal type="number">42.0</literal></expr></expr_stmt>

string literal

Element

<literal type="string">"Hello"</literal>

XPath

srcQL

string literals
```
//src:literal[@type='string']
```

find any string literal
```
FIND src:literal[@type="string"]
```

Examples

"Hello"

<expr_stmt><expr><literal type="string">"Hello"</literal></expr></expr_stmt>

'c'

<expr_stmt><expr><literal type="string">'c'</literal></expr></expr_stmt>

class Foo:
    """This is a docstring"""

<class>class <name>Foo</name><block>:<block_content>
    <expr_stmt><expr><literal type="string" format="docstring">"""This is a docstring"""</literal></expr></expr_stmt></block_content></block></class>

boolean literal

Element

<literal type="boolean">True</literal>

XPath

srcQL

boolean literals
```
//src:literal[@type='boolean']
```

find any boolean literal
```
FIND src:literal[@type="boolean"]
```
find any expression that contains True
```
FIND True
```
find any expression that contains False
```
FIND False
```

Example

True

<expr_stmt><expr><literal type="boolean">True</literal></expr></expr_stmt>

null literal

Element

<literal type="null">None</literal>

XPath

srcQL

null literals
```
//src:literal[@type='null']
```

find any None
```
FIND src:literal[@type="null"]
```
find any expression containing None
```
FIND None
```

Example

None

<expr_stmt><expr><literal type="null">None</literal></expr></expr_stmt>

complex literal

Element

<literal type="complex">2 + 3j</literal>

XPath

srcQL

complex literals
```
//src:literal[@type='complex']
```

find any complex literal
```
FIND src:literal[@type="complex"]
```

Example

1 + 2j
3 + 4J

<expr_stmt><expr><literal type="complex">1 + 2j</literal></expr></expr_stmt>
<expr_stmt><expr><literal type="complex">3 + 4J</literal></expr></expr_stmt>

ellipsis literal

Element

<literal type="ellipsis">...</literal>

XPath

srcQL

ellipsis literals
```
//src:literal[@type='ellipsis']
```

find any ellipsis literal
```
FIND src:literal[@type="ellipsis"]
```
find any expression with an ellipsis literal
```
FIND ...
```

Example

a[..., 0]

<expr_stmt><expr><name><name>a</name><index>[<expr><literal type="ellipsis">...</literal></expr>, <expr><literal type="number">0</literal></expr>]</index></name></expr></expr_stmt>

name

Element

<name>

XPath

srcQL

All names (i.e., identifiers)
```
//src:name
```

find any name
```
FIND src:name
```

Example

count
a.b
a.f()

<expr_stmt><expr><name>count</name></expr></expr_stmt>
<expr_stmt><expr><name><name>a</name><operator>.</operator><name>b</name></name></expr></expr_stmt>
<expr_stmt><expr><call><name><name>a</name><operator>.</operator><name>f</name></name><argument_list>()</argument_list></call></expr></expr_stmt>

if statement

Element

<if_stmt>

Subelements

<if>
<if type="elseif">
<else>

XPath

srcQL

if conditions
```
//src:if/src:condition
```
then
```
//src:if/src:block
```
else
```
//src:else/src:block
```
if statements without an else
```
//src:if_stmt[not(src:else)]
```
else if
```
//src:if[@type='elseif']
```
First if in a nested if statement
```
//src:if_stmt/src:if[1]
```
Second if in a nested if statement
```
//src:if_stmt/src:if[2]
```
Last if in a nested if statement
```
//src:if_stmt/src:if[last()]
```

find any instance of an if statement
```
FIND if $E:
```

Examples

if A:
    B

<if_stmt><if>if <condition><expr><name>A</name></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>B</name></expr></expr_stmt></block_content></block></if></if_stmt>

if A:
    B
else:
    C

<if_stmt><if>if <condition><expr><name>A</name></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>B</name></expr></expr_stmt>
</block_content></block></if><else>else<block>:<block_content>
    <expr_stmt><expr><name>C</name></expr></expr_stmt></block_content></block></else></if_stmt>

if A:
    B
elif A2:
    C
else:
    D

<if_stmt><if>if <condition><expr><name>A</name></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>B</name></expr></expr_stmt>
</block_content></block></if><if type="elseif">elif <condition><expr><name>A2</name></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>C</name></expr></expr_stmt>
</block_content></block></if><else>else<block>:<block_content>
    <expr_stmt><expr><name>D</name></expr></expr_stmt></block_content></block></else></if_stmt>

if(x > 5):
    y+=4

<if_stmt><if>if<condition><expr><operator>(</operator><name>x</name> <operator>&gt;</operator> <literal type="number">5</literal><operator>)</operator></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>y</name><operator>+=</operator><literal type="number">4</literal></expr></expr_stmt></block_content></block></if></if_stmt>

if  i > 0 :
    y = x / i

<if_stmt><if>if  <condition><expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr></condition> <block>:<block_content>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <name>x</name> <operator>/</operator> <name>i</name></expr></expr_stmt></block_content></block></if></if_stmt>

if i > 0:
    y = x / i
else
    x = i
    y = f( x )

<if_stmt><if>if <condition><expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <name>x</name> <operator>/</operator> <name>i</name></expr></expr_stmt>
</block_content></block></if><else>else</else></if_stmt>
    <expr_stmt><expr><name>x</name> <operator>=</operator> <name>i</name></expr></expr_stmt>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <call><name>f</name><argument_list>( <argument><expr><name>x</name></expr></argument> )</argument_list></call></expr></expr_stmt>

if i > 0:
    if j > i:
        x = j
    else:
        x = i

<if_stmt><if>if <condition><expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr></condition><block>:<block_content>
    <if_stmt><if>if <condition><expr><name>j</name> <operator>&gt;</operator> <name>i</name></expr></condition><block>:<block_content>
        <expr_stmt><expr><name>x</name> <operator>=</operator> <name>j</name></expr></expr_stmt>
</block_content></block></if>    <else>else<block>:<block_content>
        <expr_stmt><expr><name>x</name> <operator>=</operator> <name>i</name></expr></expr_stmt></block_content></block></else></if_stmt></block_content></block></if></if_stmt>

if i > 0:
    if j > i:
        x = j
else
    x = i

<if_stmt><if>if <condition><expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr></condition><block>:<block_content>
    <if_stmt><if>if <condition><expr><name>j</name> <operator>&gt;</operator> <name>i</name></expr></condition><block>:<block_content>
        <expr_stmt><expr><name>x</name> <operator>=</operator> <name>j</name></expr></expr_stmt>
</block_content></block></if></if_stmt></block_content></block></if><else>else</else></if_stmt>
    <expr_stmt><expr><name>x</name> <operator>=</operator> <name>i</name></expr></expr_stmt>

if i > 0:
 	x = i
elif i < 0:
	x = q
else:
    x = j

<if_stmt><if>if <condition><expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr></condition><block>:<block_content>
 	<expr_stmt><expr><name>x</name> <operator>=</operator> <name>i</name></expr></expr_stmt>
</block_content></block></if><if type="elseif">elif <condition><expr><name>i</name> <operator>&lt;</operator> <literal type="number">0</literal></expr></condition><block>:<block_content>
	<expr_stmt><expr><name>x</name> <operator>=</operator> <name>q</name></expr></expr_stmt>
</block_content></block></if><else>else<block>:<block_content>
    <expr_stmt><expr><name>x</name> <operator>=</operator> <name>j</name></expr></expr_stmt></block_content></block></else></if_stmt>

while statement

Element

<while>

Subelements

<condition>
<block>
<else>

XPath

srcQL

while loops
```
//src:while
```
while-loop conditions
```
//src:while/src:condition
```
while loops with a condition containing the variable i
```
//src:while[src:condition//src:name='i']
```

find any while
```
FIND while $E:
```

Example

while i >= 0:
    string1[i] = string2[i]
    i -= 1

<while>while <condition><expr><name>i</name> <operator>&gt;=</operator> <literal type="number">0</literal></expr></condition><block>:<block_content>
    <expr_stmt><expr><name><name>string1</name><index>[<expr><name>i</name></expr>]</index></name> <operator>=</operator> <name><name>string2</name><index>[<expr><name>i</name></expr>]</index></name></expr></expr_stmt>
    <expr_stmt><expr><name>i</name> <operator>-=</operator> <literal type="number">1</literal></expr></expr_stmt></block_content></block></while>

for statement

Element

<for>

Subelements

<control>
<block>
<specifier>
<else>

XPath

srcQL

for loops
```
//src:for
```
for-loop initialization statements
```
//src:for/src:control/src:init
```
for-loop conditions
```
//src:for/src:control/src:condition
```
for-loop increments
```
//src:for/src:control/src:incr
```
for loops that declare a variable with a single character name (e.g. x, i or y)
```
//src:for[string-length(src:control/src:init/src:decl/src:name)=1]
```

for loops with post-increment in the increment expression

//src:for[src:control/src:incr/src:expr//following-sibling::src:operator='++']

range-based for loops
```
//src:for[src:control//src:range]
```

find any for-loop
```
FIND for $E
```
find any “for” part in a comprehension
```
FIND src:for WITHIN src:comprehension
```

Examples

for i in range(10):
    print(i)

<for>for <control><expr><name>i</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><literal type="number">10</literal></expr></argument>)</argument_list></call></expr></range></control><block>:<block_content>
    <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><name>i</name></expr></argument>)</argument_list></call></expr></expr_stmt>
</block_content></block></for>

for i in range(max):
    if line[i] == ' ':
        space += 1
    if line[i] == '\t':
        tab += 1

<for>for <control><expr><name>i</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><name>max</name></expr></argument>)</argument_list></call></expr></range></control><block>:<block_content>
    <if_stmt><if>if <condition><expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <operator>==</operator> <literal type="string">' '</literal></expr></condition><block>:<block_content>
        <expr_stmt><expr><name>space</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></if></if_stmt>    <if_stmt><if>if <condition><expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <operator>==</operator> <literal type="string">'\t'</literal></expr></condition><block>:<block_content>
        <expr_stmt><expr><name>tab</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></if></if_stmt></block_content></block></for>

for i in range(10):
    a += x[i]

<for>for <control><expr><name>i</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><literal type="number">10</literal></expr></argument>)</argument_list></call></expr></range></control><block>:<block_content>
    <expr_stmt><expr><name>a</name> <operator>+=</operator> <name><name>x</name><index>[<expr><name>i</name></expr>]</index></name></expr></expr_stmt>
</block_content></block></for>

for int(i) in v:
    print(f"{i} ")

<for>for <control><expr><call><name>int</name><argument_list>(<argument><expr><name>i</name></expr></argument>)</argument_list></call></expr> <range>in <expr><name>v</name></expr></range></control><block>:<block_content>
    <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">f"{i} "</literal></expr></argument>)</argument_list></call></expr></expr_stmt>
</block_content></block></for>

Empty for statement

for p in v:
    pass

<for>for <control><expr><name>p</name></expr> <range>in <expr><name>v</name></expr></range></control><block>:<block_content>
    <pass>pass</pass>
</block_content></block></for>

break statement

Element

<break>

XPath

srcQL

break statements
```
//src:break
```
break statements in for loops
```
//src:for//src:break
```
for loops with break statements
```
//src:for[.//src:break]
```

find break statements
```
FIND break
```
find any for loops that contain a break statement
```
FIND for $E: CONTAINS break
```

Example

while True:
    c : str = input("Press any key, Q to quit: ")
    if c == "Q":
        break

<while>while <condition><expr><literal type="boolean">True</literal></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>c</name> <annotation>: <expr><name>str</name></expr></annotation> <operator>=</operator> <call><name>input</name><argument_list>(<argument><expr><literal type="string">"Press any key, Q to quit: "</literal></expr></argument>)</argument_list></call></expr></expr_stmt>
    <if_stmt><if>if <condition><expr><name>c</name> <operator>==</operator> <literal type="string">"Q"</literal></expr></condition><block>:<block_content>
        <break>break</break>
</block_content></block></if></if_stmt></block_content></block></while>

continue statement

Element

<continue>

XPath

srcQL

continue statements
```
//src:continue
```

find any continue keywords
```
FIND continue
```
find any for loops that contain a continue statement
```
FIND for $E: CONTAINS continue
```

Example

while i > 0:
    x = f(i)
    if x == 1:
        continue
    y += x * x
    i -= 1

<while>while <condition><expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>x</name> <operator>=</operator> <call><name>f</name><argument_list>(<argument><expr><name>i</name></expr></argument>)</argument_list></call></expr></expr_stmt>
    <if_stmt><if>if <condition><expr><name>x</name> <operator>==</operator> <literal type="number">1</literal></expr></condition><block>:<block_content>
        <continue>continue</continue>
</block_content></block></if></if_stmt>    <expr_stmt><expr><name>y</name> <operator>+=</operator> <name>x</name> <operator>*</operator> <name>x</name></expr></expr_stmt>
    <expr_stmt><expr><name>i</name> <operator>-=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></while>

return statement

Element

<return>

Subelement

<expr>

XPath

srcQL

return statements
```
//src:return
```
return expressions
```
//src:return/src:expr
```
return statements that return true
```
//src:return[src:expr='true']
```
functions with more then one return
```
//src:function[count(.//src:return)>1]
```

find any return keywords
```
FIND return
```
find any functions that contain a return keyword
```
FIND def $N(): CONTAINS return
```

Examples

return

<return>return</return>

return True

<return>return <expr><literal type="boolean">True</literal></expr></return>

return s * s

<return>return <expr><name>s</name> <operator>*</operator> <name>s</name></expr></return>

switch statement

Element

<switch>

Subelements

<condition>
<block>

XPath

srcQL

switch statements
```
//src:switch
```
switch-statement conditions
```
//src:switch/src:condition
```

find any match statement
```
FIND match $E:
```

Examples

match c:

    case 'A':
        capa += 1
    case 'a':
        lettera += 1
    case _:
        total += 1

<switch>match <condition><expr><name>c</name></expr></condition><block>:<block_content>

    <case>case <expr><literal type="string">'A'</literal></expr><block>:<block_content>
        <expr_stmt><expr><name>capa</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></case>    <case>case <expr><literal type="string">'a'</literal></expr><block>:<block_content>
        <expr_stmt><expr><name>lettera</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></case>    <case>case <expr><name>_</name></expr><block>:<block_content>
        <expr_stmt><expr><name>total</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></case></block_content></block></switch>

match i:

    case -1:
        n += 1

    case 0:
        z += 1

    case 1:
        p += 1;

<switch>match <condition><expr><name>i</name></expr></condition><block>:<block_content>

    <case>case <expr><operator>-</operator><literal type="number">1</literal></expr><block>:<block_content>
        <expr_stmt><expr><name>n</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></case>
    <case>case <expr><literal type="number">0</literal></expr><block>:<block_content>
        <expr_stmt><expr><name>z</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></case>
    <case>case <expr><literal type="number">1</literal></expr><block>:<block_content>
        <expr_stmt><expr><name>p</name> <operator>+=</operator> <literal type="number">1</literal></expr>;</expr_stmt>
</block_content></block></case></block_content></block></switch>

case statement

Element

<case>

Subelements

<expr>
<block>
<alias>
<condition>

XPath

srcQL

case labels
```
//src:case
```
case labels that use SATURDAY
```
//src:case[.//src:name='SATURDAY']
```

switch statements with a case that uses SATURDAY

//src:switch[src:block/src:block_content/src:case//src:name='SATURDAY']

find any case statements
```
FIND case $E:
```
find any case statements with the wildcard operator (_)
```
FIND case _:
```

Examples

    case x:

    <case>case <expr><name>x</name></expr><block>:<block_content/></block></case>

    case SATURDAY:

    <case>case <expr><name>SATURDAY</name></expr><block>:<block_content/></block></case>

block

Element

<block>

Subelement

<block_content>

XPath

srcQL

blocks
```
//src:block
```
variable declarations in a block
```
//src:block//src:decl_stmt
```

top-level variable declarations in a block

//src:block/src:block_content/src:decl_stmt

find block
```
FIND src:block
```

Examples

if A:
    B
elif A2:
    C
else:
    D

<if_stmt><if>if <condition><expr><name>A</name></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>B</name></expr></expr_stmt>
</block_content></block></if><if type="elseif">elif <condition><expr><name>A2</name></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>C</name></expr></expr_stmt>
</block_content></block></if><else>else<block>:<block_content>
    <expr_stmt><expr><name>D</name></expr></expr_stmt></block_content></block></else></if_stmt>

match c:

    case 'A':
        capa += 1
    case 'a':
        lettera += 1
    case _:
        total += 1

<switch>match <condition><expr><name>c</name></expr></condition><block>:<block_content>

    <case>case <expr><literal type="string">'A'</literal></expr><block>:<block_content>
        <expr_stmt><expr><name>capa</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></case>    <case>case <expr><literal type="string">'a'</literal></expr><block>:<block_content>
        <expr_stmt><expr><name>lettera</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></case>    <case>case <expr><name>_</name></expr><block>:<block_content>
        <expr_stmt><expr><name>total</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></case></block_content></block></switch>

for i in range(10):
    a += x[i]

<for>for <control><expr><name>i</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><literal type="number">10</literal></expr></argument>)</argument_list></call></expr></range></control><block>:<block_content>
    <expr_stmt><expr><name>a</name> <operator>+=</operator> <name><name>x</name><index>[<expr><name>i</name></expr>]</index></name></expr></expr_stmt>
</block_content></block></for>

expression statement

Element

<expr_stmt>

Subelement

<expr>

XPath

expression statements
```
//src:expr_stmt
```

Example

i += 1

<expr_stmt><expr><name>i</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>

assert statement

Element

<assert>

Subelement

<condition>

XPath

srcQL

assert statements
```
//src:assert
```
methods with assert statements
```
//src:function[.//src:assert]
```

find all assert statements
```
FIND assert $E
```

Examples

assert x == 3

<assert>assert <condition><expr><name>x</name> <operator>==</operator> <literal type="number">3</literal></expr></condition></assert>

assert y != 0, "y can't be zero"

<assert>assert <condition><expr><name>y</name> <operator>!=</operator> <literal type="number">0</literal></expr></condition>, <expr><literal type="string">"y can't be zero"</literal></expr></assert>

parameter

Element

<parameter>

Subelements

<annotation>
<expr>
<init>

XPath

srcQL

parameter
```
//src:parameter
```

find any parameter
```
FIND src:parameter
```

Examples

def function(foo):

<function>def <name>function</name><parameter_list>(<parameter><name>foo</name></parameter>)</parameter_list><block>:<block_content/></block></function>

def function(foo: int, bar: str):

<function>def <name>function</name><parameter_list>(<parameter><name>foo</name><annotation>: <expr><name>int</name></expr></annotation></parameter>, <parameter><name>bar</name><annotation>: <expr><name>str</name></expr></annotation></parameter>)</parameter_list><block>:<block_content/></block></function>

parameter modifiers

Element

<parameter type="modifier">

XPath

srcQL

parameter modifiers
```
//src:parameter[@type='modifier']
```

find any parameter modifier
```
FIND src:parameter[@type="modifier"]
```

Examples

def shiftHues(hexCodes:list[str], *):

<function>def <name>shiftHues</name><parameter_list>(<parameter><name>hexCodes</name><annotation>:<expr><name><name>list</name><index>[<expr><name>str</name></expr>]</index></name></expr></annotation></parameter>, <parameter type="modifier">*</parameter>)</parameter_list><block>:<block_content/></block></function>

def f(first, second, third, /):
    print(f"first {first}, second {second}, third {third}")

<function>def <name>f</name><parameter_list>(<parameter><name>first</name></parameter>, <parameter><name>second</name></parameter>, <parameter><name>third</name></parameter>, <parameter type="modifier">/</parameter>)</parameter_list><block>:<block_content>
    <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">f"first {first}, second {second}, third {third}"</literal></expr></argument>)</argument_list></call></expr></expr_stmt></block_content></block></function>

argument parameter

Element

<parameter type="args">

Subelements

<annotation>
<expr>

XPath

srcQL

arbitrary argument parameter
```
//src:parameter[@type='args']
```

find any arbitrary argument parameter
```
FIND src:parameter[@type="args"]
```

Example

def function(*collection):
    for arg in collection:
        print(arg)

<function>def <name>function</name><parameter_list>(<parameter type="args">*<name>collection</name></parameter>)</parameter_list><block>:<block_content>
    <for>for <control><expr><name>arg</name></expr> <range>in <expr><name>collection</name></expr></range></control><block>:<block_content>
        <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><name>arg</name></expr></argument>)</argument_list></call></expr></expr_stmt></block_content></block></for></block_content></block></function>

keyword argument parameter

Element

<parameter type="kwargs">

Subelements

<annotation>
<expr>

XPath

srcQL

keyword argument parameter
```
//src:parameter[@type='kwargs']
```

find any keyword argument parameter
```
FIND src:parameter[@type="kwargs"]
```

Example

def summary(**stats):
    print("SUMMARY")
    for key, value in stats.items():
        print("{}: {}".format(key,value))

summary(Name = "John Smith", Gender = "Male", Age = 23, Height = 68)

<function>def <name>summary</name><parameter_list>(<parameter type="kwargs">**<name>stats</name></parameter>)</parameter_list><block>:<block_content>
    <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">"SUMMARY"</literal></expr></argument>)</argument_list></call></expr></expr_stmt>
    <for>for <control><expr><tuple><expr><name>key</name></expr>, <expr><name>value</name></expr></tuple></expr> <range>in <expr><call><name><name>stats</name><operator>.</operator><name>items</name></name><argument_list>()</argument_list></call></expr></range></control><block>:<block_content>
        <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">"{}: {}"</literal><operator>.</operator><call><name>format</name><argument_list>(<argument><expr><name>key</name></expr></argument>,<argument><expr><name>value</name></expr></argument>)</argument_list></call></expr></argument>)</argument_list></call></expr></expr_stmt>
</block_content></block></for></block_content></block></function>
<expr_stmt><expr><call><name>summary</name><argument_list>(<argument><name>Name</name> = <expr><literal type="string">"John Smith"</literal></expr></argument>, <argument><name>Gender</name> = <expr><literal type="string">"Male"</literal></expr></argument>, <argument><name>Age</name> = <expr><literal type="number">23</literal></expr></argument>, <argument><name>Height</name> = <expr><literal type="number">68</literal></expr></argument>)</argument_list></call></expr></expr_stmt>

delete

Element

<delete>

Subelement

<name>

XPath

srcQL

delete
```
//src:delete
```

find delete statement
```
FIND del $N
```

Examples

del x

<delete>del <name>x</name></delete>

del x[0]

<delete>del <name><name>x</name><index>[<expr><literal type="number">0</literal></expr>]</index></name></delete>

execute statement

Element

<exec>

Subelement

<expr>

XPath

srcQL

execute statement
```
//src:exec
```

find any Python 2 exec statements
```
FIND exec $E
```

Example

x = "print('Hello')"
exec (x)

<expr_stmt><expr><name>x</name> <operator>=</operator> <literal type="string">"print('Hello')"</literal></expr></expr_stmt>
<expr_stmt><expr><call><name>exec</name> <argument_list>(<argument><expr><name>x</name></expr></argument>)</argument_list></call></expr></expr_stmt>

global statement

Element

<global>

Subelement

<name>

XPath

srcQL

global statement
```
//src:global
```

find any global statement
```
FIND global $N
```

Example

def incr():
    global a
    a += 1
    return

<function>def <name>incr</name><parameter_list>()</parameter_list><block>:<block_content>
    <global>global <name>a</name></global>
    <expr_stmt><expr><name>a</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
    <return>return</return></block_content></block></function>

import statement

Element

<import>

Subelements

<from>
<name>
<alias>

XPath

srcQL

import statement
```
//src:import
```

find any import statement
```
FIND import $N
```
find any “from … import …” statement
```
FIND from $A import $B
```

Examples

import sys

<import>import <name>sys</name></import>

import numpy as np

<import>import <name>numpy</name> <alias>as <expr><name>np</name></expr></alias></import>

from pathlib import Path

<import><from>from <name>pathlib</name></from> import <name>Path</name></import>

nonlocal

Element

<nonlocal>

Subelement

<name>

XPath

srcQL

nonlocal
```
//src:nonlocal
```

find any nonlocal statement
```
FIND nonlocal $N
```

Example

def func1():
  a = 1
  def func2():
    nonlocal a
    a = 2
  func2()
  return a

print(func1())

<function>def <name>func1</name><parameter_list>()</parameter_list><block>:<block_content>
  <expr_stmt><expr><name>a</name> <operator>=</operator> <literal type="number">1</literal></expr></expr_stmt>
  <function>def <name>func2</name><parameter_list>()</parameter_list><block>:<block_content>
    <nonlocal>nonlocal <name>a</name></nonlocal>
    <expr_stmt><expr><name>a</name> <operator>=</operator> <literal type="number">2</literal></expr></expr_stmt>
</block_content></block></function>  <expr_stmt><expr><call><name>func2</name><argument_list>()</argument_list></call></expr></expr_stmt>
  <return>return <expr><name>a</name></expr></return>
</block_content></block></function>
<expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><call><name>func1</name><argument_list>()</argument_list></call></expr></argument>)</argument_list></call></expr></expr_stmt>

pass statement

Element

<pass>

XPath

srcQL

pass statement
```
//src:pass
```

find any pass keywords
```
FIND pass
```
find any functions that contain a pass keyword
```
FIND def $N(): CONTAINS pass
```

Example

def function():
    pass

<function>def <name>function</name><parameter_list>()</parameter_list><block>:<block_content>
    <pass>pass</pass></block_content></block></function>

print statement

Element

<print>

Subelement

<expr>

XPath

srcQL

print statement
```
//src:print
```

find any Python 2 print statements
```
FIND print $E
```

Example

print("Hello World")

<expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">"Hello World"</literal></expr></argument>)</argument_list></call></expr></expr_stmt>

with statement

Element

<with>

Subelements

<specifier>
<alias>
<block>
<expr>

XPath

srcQL

with statement
```
//src:with
```

find any with statement
```
FIND with $E:
```
find any asynchrounous with statement
```
FIND async with $E:
```

Example

with open("text.txt","r") as text:
    text.read()

<with>with <expr><call><name>open</name><argument_list>(<argument><expr><literal type="string">"text.txt"</literal></expr></argument>,<argument><expr><literal type="string">"r"</literal></expr></argument>)</argument_list></call></expr> <alias>as <expr><name>text</name></expr></alias><block>:<block_content>
    <expr_stmt><expr><call><name><name>text</name><operator>.</operator><name>read</name></name><argument_list>()</argument_list></call></expr></expr_stmt></block_content></block></with>

yield statement

Element

<yield>

Subelement

<expr>

XPath

srcQL

yield statement
```
//src:yield
```

find any yield statement
```
FIND src:yield
```

Example

def ten():
    for j in range(10):
        yield j

r = ten()

for n in r:
    print(n)

<function>def <name>ten</name><parameter_list>()</parameter_list><block>:<block_content>
    <for>for <control><expr><name>j</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><literal type="number">10</literal></expr></argument>)</argument_list></call></expr></range></control><block>:<block_content>
        <yield>yield <expr><name>j</name></expr></yield>
</block_content></block></for></block_content></block></function>
<expr_stmt><expr><name>r</name> <operator>=</operator> <call><name>ten</name><argument_list>()</argument_list></call></expr></expr_stmt>

<for>for <control><expr><name>n</name></expr> <range>in <expr><name>r</name></expr></range></control><block>:<block_content>
    <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><name>n</name></expr></argument>)</argument_list></call></expr></expr_stmt>
</block_content></block></for>

yield from statement

Element

<yield type="from">

Subelement

<expr>

XPath

srcQL

yield from statement
```
//src:yield[@type='from']
```

find any yield from statement
```
FIND yield from $E
```

Example

def wrapper(g : Generator):
    yield from g

<function>def <name>wrapper</name><parameter_list>(<parameter><name>g</name> <annotation>: <expr><name>Generator</name></expr></annotation></parameter>)</parameter_list><block>:<block_content>
    <yield type="from">yield from <expr><name>g</name></expr></yield>
</block_content></block></function>

condition

Element

<condition>

Subelement

<expr>

XPath

srcQL

conditions, including ternary conditions
```
//src:condition
```
condition expressions
```
//src:condition/src:expr
```
if conditions
```
//src:if/src:condition
```
while conditions
```
//src:while/src:condition
```
ternary conditions
```
//src:ternary/src:condition
```

find any condition
```
FIND src:condition
```
find any (optional) condition located in a comprehension
```
FIND src:condition WITHIN src:comprehension
```

Examples

if(x > 5):
    y+=4

<if_stmt><if>if<condition><expr><operator>(</operator><name>x</name> <operator>&gt;</operator> <literal type="number">5</literal><operator>)</operator></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>y</name><operator>+=</operator><literal type="number">4</literal></expr></expr_stmt></block_content></block></if></if_stmt>

while i >= 0:
    string1[i] = string2[i]
    i -= 1

<while>while <condition><expr><name>i</name> <operator>&gt;=</operator> <literal type="number">0</literal></expr></condition><block>:<block_content>
    <expr_stmt><expr><name><name>string1</name><index>[<expr><name>i</name></expr>]</index></name> <operator>=</operator> <name><name>string2</name><index>[<expr><name>i</name></expr>]</index></name></expr></expr_stmt>
    <expr_stmt><expr><name>i</name> <operator>-=</operator> <literal type="number">1</literal></expr></expr_stmt></block_content></block></while>

block content

Element

<block_content>

XPath

srcQL

block contents
```
//src:block_content
```
declaration block_contents
```
//src:decl/src:block/src:block_content
```

function block_contents

//src:function/src:block/src:block_content

find block content
```
FIND src:block_content
```

Examples

def function():
    pass

<function>def <name>function</name><parameter_list>()</parameter_list><block>:<block_content>
    <pass>pass</pass></block_content></block></function>

if(x > 5):
    y+=4

<if_stmt><if>if<condition><expr><operator>(</operator><name>x</name> <operator>&gt;</operator> <literal type="number">5</literal><operator>)</operator></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>y</name><operator>+=</operator><literal type="number">4</literal></expr></expr_stmt></block_content></block></if></if_stmt>

if

Element

<if>

Subelements

<condition>
<block>

XPath

srcQL

all ifs
```
//src:if
```

find any if keyword
```
FIND src:if
```
find any if keywords that are part of a ternary
```
FIND srcif WITHIN src:ternary
```

Examples

if(x > 5):
    y+=4

<if_stmt><if>if<condition><expr><operator>(</operator><name>x</name> <operator>&gt;</operator> <literal type="number">5</literal><operator>)</operator></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>y</name><operator>+=</operator><literal type="number">4</literal></expr></expr_stmt></block_content></block></if></if_stmt>

if  i > 0 :
    y = x / i

<if_stmt><if>if  <condition><expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr></condition> <block>:<block_content>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <name>x</name> <operator>/</operator> <name>i</name></expr></expr_stmt></block_content></block></if></if_stmt>

if i > 0:
    y = x / i
else
    x = i
    y = f( x )

<if_stmt><if>if <condition><expr><name>i</name> <operator>&gt;</operator> <literal type="number">0</literal></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <name>x</name> <operator>/</operator> <name>i</name></expr></expr_stmt>
</block_content></block></if><else>else</else></if_stmt>
    <expr_stmt><expr><name>x</name> <operator>=</operator> <name>i</name></expr></expr_stmt>
    <expr_stmt><expr><name>y</name> <operator>=</operator> <call><name>f</name><argument_list>( <argument><expr><name>x</name></expr></argument> )</argument_list></call></expr></expr_stmt>

else

Element

<else>

Subelement

<block>

XPath

srcQL

all elses
```
//src:else
```

find any else keyword
```
FIND src:else
```
find any else keywords that are part of a ternary
```
FIND src:else WITHIN src:ternary
```

Example

if then else

if A:
    B
else:
    C

<if_stmt><if>if <condition><expr><name>A</name></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>B</name></expr></expr_stmt>
</block_content></block></if><else>else<block>:<block_content>
    <expr_stmt><expr><name>C</name></expr></expr_stmt></block_content></block></else></if_stmt>

else if

Element

<if type="elseif">

Subelements

<condition>
<block>

XPath

srcQL

all else ifs
```
//src:if[@type='elseif']
```

find all else if statements
```
FIND src:if[@type="elseif"]
```

Example

if then elif

if A:
    B
elif A2:
    C
else:
    D

<if_stmt><if>if <condition><expr><name>A</name></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>B</name></expr></expr_stmt>
</block_content></block></if><if type="elseif">elif <condition><expr><name>A2</name></expr></condition><block>:<block_content>
    <expr_stmt><expr><name>C</name></expr></expr_stmt>
</block_content></block></if><else>else<block>:<block_content>
    <expr_stmt><expr><name>D</name></expr></expr_stmt></block_content></block></else></if_stmt>

control

Element

<control>

Subelements

<init>
<condition>

XPath

srcQL

initialization and condition of for loops
```
//src:control
```

find any code located after a “for” keyword yet before the start of the block (i.e, the “control” parts)
```
FIND src:control
```
find any “control” parts in for-loops
```
FIND src:control WITHIN for $E:
```
find any “control” parts in list comprehension
```
src:control WITHIN [$A for $B in $C]
```

Example

for i in range(10):
    a += x[i]

<for>for <control><expr><name>i</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><literal type="number">10</literal></expr></argument>)</argument_list></call></expr></range></control><block>:<block_content>
    <expr_stmt><expr><name>a</name> <operator>+=</operator> <name><name>x</name><index>[<expr><name>i</name></expr>]</index></name></expr></expr_stmt>
</block_content></block></for>

annotation

Element

<annotation>

XPath

srcQL

annotation
```
//src:annotation
```

find all annotated parameters

FIND src:parameter CONTAINS src:annotation

find all function type annotations
```
FIND def $N() -> $E
```

Example

c : str = "string"

<expr_stmt><expr><name>c</name> <annotation>: <expr><name>str</name></expr></annotation> <operator>=</operator> <literal type="string">"string"</literal></expr></expr_stmt>

expr

Element

<expr>

XPath

srcQL

expr
```
//src:expr
```

find any expression
```
FIND src:expr
```

Example

a + b

<expr_stmt><expr><name>a</name> <operator>+</operator> <name>b</name></expr></expr_stmt>

alias

Element

<alias>

XPath

srcQL

aliases
```
//src:alias
```

find any alias
```
FIND as $E
```

Example

with open("text.txt","r") as text:
    text.read()

<with>with <expr><call><name>open</name><argument_list>(<argument><expr><literal type="string">"text.txt"</literal></expr></argument>,<argument><expr><literal type="string">"r"</literal></expr></argument>)</argument_list></call></expr> <alias>as <expr><name>text</name></expr></alias><block>:<block_content>
    <expr_stmt><expr><call><name><name>text</name><operator>.</operator><name>read</name></name><argument_list>()</argument_list></call></expr></expr_stmt></block_content></block></with>

super class

Element

<super>

XPath

srcQL

super class
```
//src:super
```

find any super class
```
FIND src:super
```

Example

class Foo(Bar1, OtherBar):
	pass

<class>class <name>Foo</name><super_list>(<super><expr><name>Bar1</name></expr></super>, <super><expr><name>OtherBar</name></expr></super>)</super_list><block>:<block_content>
	<pass>pass</pass></block_content></block></class>

async specifier

Element

<specifier>async</specifier>

XPath

srcQL

async specifier

//src:name[src:name/src:specifier='async']

find any async specifier
```
FIND src:specifier
```
find any asynchronous function
```
FIND async def $N():
```
find any asynchronous for-loop
```
FIND async for $E():
```

Example

async used as a specifier

async def ExampleMethodAsync():

<function><specifier>async</specifier> def <name>ExampleMethodAsync</name><parameter_list>()</parameter_list><block>:<block_content/></block></function>

function

Element

<function>

Subelements

<annotation>
<name>
<parameter_list>
<parameter_list type="generic">
<block>
<attribute>
<specifier>

XPath

srcQL

function definitions
```
//src:function
```

find any function
```
FIND def $N():
```
find any asynchronous function
```
FIND async def $N():
```
find any generic function (Python 3.12 syntax)
```
FIND def $N[]():
```

Examples

def function(foo):

<function>def <name>function</name><parameter_list>(<parameter><name>foo</name></parameter>)</parameter_list><block>:<block_content/></block></function>

def function(foo: int, bar: str):

<function>def <name>function</name><parameter_list>(<parameter><name>foo</name><annotation>: <expr><name>int</name></expr></annotation></parameter>, <parameter><name>bar</name><annotation>: <expr><name>str</name></expr></annotation></parameter>)</parameter_list><block>:<block_content/></block></function>

def function(*collection):
    for arg in collection:
        print(arg)

<function>def <name>function</name><parameter_list>(<parameter type="args">*<name>collection</name></parameter>)</parameter_list><block>:<block_content>
    <for>for <control><expr><name>arg</name></expr> <range>in <expr><name>collection</name></expr></range></control><block>:<block_content>
        <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><name>arg</name></expr></argument>)</argument_list></call></expr></expr_stmt></block_content></block></for></block_content></block></function>

def summary(**stats):
    print("SUMMARY")
    for key, value in stats.items():
        print("{}: {}".format(key,value))

summary(Name = "John Smith", Gender = "Male", Age = 23, Height = 68)

<function>def <name>summary</name><parameter_list>(<parameter type="kwargs">**<name>stats</name></parameter>)</parameter_list><block>:<block_content>
    <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">"SUMMARY"</literal></expr></argument>)</argument_list></call></expr></expr_stmt>
    <for>for <control><expr><tuple><expr><name>key</name></expr>, <expr><name>value</name></expr></tuple></expr> <range>in <expr><call><name><name>stats</name><operator>.</operator><name>items</name></name><argument_list>()</argument_list></call></expr></range></control><block>:<block_content>
        <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">"{}: {}"</literal><operator>.</operator><call><name>format</name><argument_list>(<argument><expr><name>key</name></expr></argument>,<argument><expr><name>value</name></expr></argument>)</argument_list></call></expr></argument>)</argument_list></call></expr></expr_stmt>
</block_content></block></for></block_content></block></function>
<expr_stmt><expr><call><name>summary</name><argument_list>(<argument><name>Name</name> = <expr><literal type="string">"John Smith"</literal></expr></argument>, <argument><name>Gender</name> = <expr><literal type="string">"Male"</literal></expr></argument>, <argument><name>Age</name> = <expr><literal type="number">23</literal></expr></argument>, <argument><name>Height</name> = <expr><literal type="number">68</literal></expr></argument>)</argument_list></call></expr></expr_stmt>

lambda functions

Element

<lambda>

Subelements

<parameter>
<expr>

XPath

srcQL

lambda functions
```
//src:lambda
```
lambda functions without a specified return type
```
//src:lambda[not(src:type)]
```
lambdas which have a the return type of int
```
//src:lambda[src:type/src:name'int']
```

find any lambda function
```
FIND src:lambda
```

Examples

lambda x : 0

<expr_stmt><expr><lambda>lambda <parameter><name>x</name></parameter> : <expr><literal type="number">0</literal></expr></lambda></expr></expr_stmt>

lambda x : function(x)

<expr_stmt><expr><lambda>lambda <parameter><name>x</name></parameter> : <expr><call><name>function</name><argument_list>(<argument><expr><name>x</name></expr></argument>)</argument_list></call></expr></lambda></expr></expr_stmt>

lambda x : int(function(x))

<expr_stmt><expr><lambda>lambda <parameter><name>x</name></parameter> : <expr><call><name>int</name><argument_list>(<argument><expr><call><name>function</name><argument_list>(<argument><expr><name>x</name></expr></argument>)</argument_list></call></expr></argument>)</argument_list></call></expr></lambda></expr></expr_stmt>

typedef

Element

<typedef>

Subelements

<name>
<expr>

XPath

srcQL

typedefs
```
//src:typedef
```
types in typedefs
```
//src:typedef/src:type
```
typedef names
```
//src:typedef/src:name
```
typedefs that define a struct
```
//src:typedef[src:type/src:struct]
```
typedefs that declare a function type
```
//src:typedef[src:function_decl]
```

typedefs of function pointers

//src:typedef[contains(src:function_decl,')')]

names of typedefs of function pointers

//src:typedef/src:function_decl[contains(.,')')]/src:name

find any Python 3.12 type aliases
```
FIND type $N = $E
```
find any Python 3.12 generic type aliases
```
FIND type $N[] = $E
```

Examples

type S = str
type intTable = list[list[int]]
type condition = bool

<typedef>type <name>S</name> = <expr><name>str</name></expr></typedef>
<typedef>type <name>intTable</name> = <expr><name><name>list</name><index>[<expr><name><name>list</name><index>[<expr><name>int</name></expr>]</index></name></expr>]</index></name></expr></typedef>
<typedef>type <name>condition</name> = <expr><name>bool</name></expr></typedef>

class club:
    name : str
    size : int
    year : int

type GROUP = club

<class>class <name>club</name><block>:<block_content>
    <expr_stmt><expr><name>name</name> <annotation>: <expr><name>str</name></expr></annotation></expr></expr_stmt>
    <expr_stmt><expr><name>size</name> <annotation>: <expr><name>int</name></expr></annotation></expr></expr_stmt>
    <expr_stmt><expr><name>year</name> <annotation>: <expr><name>int</name></expr></annotation></expr></expr_stmt>
</block_content></block></class>
<typedef>type <name>GROUP</name> = <expr><name>club</name></expr></typedef>

declaration initialization

Element

<init>

XPath

srcQL

initialization
```
//src:init
```
array declarations with an initialization
```
//src:decl[src:name/src:index][src:init]
```

function declarations with default parameters

//src:function_decl[src:parameter_list/src:parameter/src:decl/src:init]

find any initialization
```
FIND src:init
```
find any initialization in a parameter list
```
FIND src:init WITHIN src:parameter_list
```

Example

def point(x = 0, y = 0, z = 0):

<function>def <name>point</name><parameter_list>(<parameter><name>x</name> <init>= <expr><literal type="number">0</literal></expr></init></parameter>, <parameter><name>y</name> <init>= <expr><literal type="number">0</literal></expr></init></parameter>, <parameter><name>z</name> <init>= <expr><literal type="number">0</literal></expr></init></parameter>)</parameter_list><block>:<block_content/></block></function>

range

Element

<range>

Subelement

<expr>

XPath

srcQL

loop ranges
```
//src:decl[src:range]
```

find any code located included after an “in” keyword in a for-loop before the start of the block (i.e., the “range” parts)
```
FIND src:range
```
find any “range” parts in for-loops
```
FIND src:range WITHIN for $E:
```
find any “range” parts in list comprehensions
```
FIND src:range WITHIN [$A for $B in $C]
```

Examples

for i in range(max):
    if line[i] == ' ':
        space += 1
    if line[i] == '\t':
        tab += 1

<for>for <control><expr><name>i</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><name>max</name></expr></argument>)</argument_list></call></expr></range></control><block>:<block_content>
    <if_stmt><if>if <condition><expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <operator>==</operator> <literal type="string">' '</literal></expr></condition><block>:<block_content>
        <expr_stmt><expr><name>space</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></if></if_stmt>    <if_stmt><if>if <condition><expr><name><name>line</name><index>[<expr><name>i</name></expr>]</index></name> <operator>==</operator> <literal type="string">'\t'</literal></expr></condition><block>:<block_content>
        <expr_stmt><expr><name>tab</name> <operator>+=</operator> <literal type="number">1</literal></expr></expr_stmt>
</block_content></block></if></if_stmt></block_content></block></for>

for i in range(10):
    a += x[i]

<for>for <control><expr><name>i</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><literal type="number">10</literal></expr></argument>)</argument_list></call></expr></range></control><block>:<block_content>
    <expr_stmt><expr><name>a</name> <operator>+=</operator> <name><name>x</name><index>[<expr><name>i</name></expr>]</index></name></expr></expr_stmt>
</block_content></block></for>

class definition

Element

<class>

Subelements

<name>
<attribute>
<super_list>
<parameter_list type="generic">
<block>

XPath

srcQL

class definitions
```
//src:class
```
classes with the name foo
```
//src:class[src:name='foo']
```
function definitions in classes
```
//src:class//src:function
```
function declarations in classes
```
//src:class//src:function_decl
```

find any class:
```
FIND class $N
```
find any generic class (Python 3.12 syntax):
```
FIND class $N[]
```

Examples

class Foo:
    pass

<class>class <name>Foo</name><block>:<block_content>
    <pass>pass</pass></block_content></block></class>

class Foo(bar):
    pass

<class>class <name>Foo</name><super_list>(<super><expr><name>bar</name></expr></super>)</super_list><block>:<block_content>
    <pass>pass</pass></block_content></block></class>

class Foo:
	def __init__(self):
		pass

<class>class <name>Foo</name><block>:<block_content>
	<function>def <name>__init__</name><parameter_list>(<parameter><name>self</name></parameter>)</parameter_list><block>:<block_content>
		<pass>pass</pass></block_content></block></function></block_content></block></class>

class Foo:
	def foo():
		pass

<class>class <name>Foo</name><block>:<block_content>
	<function>def <name>foo</name><parameter_list>()</parameter_list><block>:<block_content>
		<pass>pass</pass></block_content></block></function></block_content></block></class>

class Foo:
	def __del__(self):
		pass

<class>class <name>Foo</name><block>:<block_content>
	<function>def <name>__del__</name><parameter_list>(<parameter><name>self</name></parameter>)</parameter_list><block>:<block_content>
		<pass>pass</pass></block_content></block></function></block_content></block></class>

class Foo:
	def __init__(self, bar):
		self.bar = bar
	def __del__(self):
		del self.bar

<class>class <name>Foo</name><block>:<block_content>
	<function>def <name>__init__</name><parameter_list>(<parameter><name>self</name></parameter>, <parameter><name>bar</name></parameter>)</parameter_list><block>:<block_content>
		<expr_stmt><expr><name><name>self</name><operator>.</operator><name>bar</name></name> <operator>=</operator> <name>bar</name></expr></expr_stmt>
</block_content></block></function>	<function>def <name>__del__</name><parameter_list>(<parameter><name>self</name></parameter>)</parameter_list><block>:<block_content>
		<delete>del <name><name>self</name><operator>.</operator><name>bar</name></name></delete></block_content></block></function></block_content></block></class>

inheritance list

Element

<super_list>

Subelements

<super>
<expr>

XPath

srcQL

classes with at least one super class
```
//src:class[src:super]
```
classes that inherit from bar
```
//src:class[src:super/src:name='bar']
```

find any “super” list
```
FIND src:super_list
```
find any classes that contain a super list
```
FIND class $N():
```

Example

class Foo(Bar1, OtherBar):
	pass

<class>class <name>Foo</name><super_list>(<super><expr><name>Bar1</name></expr></super>, <super><expr><name>OtherBar</name></expr></super>)</super_list><block>:<block_content>
	<pass>pass</pass></block_content></block></class>

function call

Element

<call>

Subelements

<name>
<argument_list>

XPath

srcQL

function calls
```
//src:call
```

find any function calls
```
FIND $N()
```
find any top-level function calls (i.e, expression statements)
```
FIND $N();
```

Examples

print("Hello World")

<expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">"Hello World"</literal></expr></argument>)</argument_list></call></expr></expr_stmt>

for int(i) in v:
    print(f"{i} ")

<for>for <control><expr><call><name>int</name><argument_list>(<argument><expr><name>i</name></expr></argument>)</argument_list></call></expr> <range>in <expr><name>v</name></expr></range></control><block>:<block_content>
    <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">f"{i} "</literal></expr></argument>)</argument_list></call></expr></expr_stmt>
</block_content></block></for>

ternary operator

Element

<ternary>

Subelements

<condition>
<else>

XPath

srcQL

ternary operators
```
//src:ternary
```

find any ternary
```
FIND src:ternary
```

Example

x if a else y

<expr_stmt><expr><name>x</name> <ternary>if <condition><expr><name>a</name></expr></condition> <else>else <expr><name>y</name></expr></else></ternary></expr></expr_stmt>

argument

Element

<argument>

Subelements

<name>
<expr>

XPath

srcQL

argument
```
//src:argument
```

find any argument in a function call
```
FIND src:argument
```
find any arguments that unpack iterables (lists, tuples, sets, etc.)
```
FIND src:argument CONTAINS *
```
find any arguments that unpack dictionaries
```
FIND src:argument CONTAINS **
```
find any function calls that contain at least one named argument
```
FIND $C($N = $E)
```

Example

function(foo: int)

<expr_stmt><expr><call><name>function</name><argument_list>(<argument><expr><name>foo</name><annotation>: <expr><name>int</name></expr></annotation></expr></argument>)</argument_list></call></expr></expr_stmt>

argument list

Element

<argument_list>

Subelement

<argument>

XPath

srcQL

argument list
```
//src:argument_list
```

find a list of arguments
```
FIND src:argument_list
```

Example

function(foo: int, bar: str)

<expr_stmt><expr><call><name>function</name><argument_list>(<argument><expr><name>foo</name><annotation>: <expr><name>int</name></expr></annotation></expr></argument>, <argument><expr><name>bar</name><annotation>: <expr><name>str</name></expr></annotation></expr></argument>)</argument_list></call></expr></expr_stmt>

list

Element

<array>

Subelements

<expr>
<comprehension>

XPath

srcQL

array
```
//src:array
```

find any list
```
FIND src:array
```
find any list comprehension
```
FIND [$A for $B in $C]
```

Examples

A : list[str] = []

<expr_stmt><expr><name>A</name> <annotation>: <expr><name><name>list</name><index>[<expr><name>str</name></expr>]</index></name></expr></annotation> <operator>=</operator> <array>[]</array></expr></expr_stmt>

matrix : list[float] = [[None for _ in range(15)] for _ in range(10)]

<expr_stmt><expr><name>matrix</name> <annotation>: <expr><name><name>list</name><index>[<expr><name>float</name></expr>]</index></name></expr></annotation> <operator>=</operator> <array>[<expr><array>[<expr><literal type="null">None</literal></expr> <comprehension><for>for <control><expr><name>_</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><literal type="number">15</literal></expr></argument>)</argument_list></call></expr></range></control></for></comprehension>]</array></expr> <comprehension><for>for <control><expr><name>_</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><literal type="number">10</literal></expr></argument>)</argument_list></call></expr></range></control></for></comprehension>]</array></expr></expr_stmt>

class pair:
  x : float = None
  y : float = None

complex : list[pair] = [pair() for entry in range(100)]

<class>class <name>pair</name><block>:<block_content>
  <expr_stmt><expr><name>x</name> <annotation>: <expr><name>float</name></expr></annotation> <operator>=</operator> <literal type="null">None</literal></expr></expr_stmt>
  <expr_stmt><expr><name>y</name> <annotation>: <expr><name>float</name></expr></annotation> <operator>=</operator> <literal type="null">None</literal></expr></expr_stmt>
</block_content></block></class>
<expr_stmt><expr><name>complex</name> <annotation>: <expr><name><name>list</name><index>[<expr><name>pair</name></expr>]</index></name></expr></annotation> <operator>=</operator> <array>[<expr><call><name>pair</name><argument_list>()</argument_list></call></expr> <comprehension><for>for <control><expr><name>entry</name></expr> <range>in <expr><call><name>range</name><argument_list>(<argument><expr><literal type="number">100</literal></expr></argument>)</argument_list></call></expr></range></control></for></comprehension>]</array></expr></expr_stmt>

comprehension

Element

<comprehension>

Subelements

<for>
<specifier>
<control>
<range>
<if>

XPath

srcQL

comprehension
```
//src:comprehension
```

find any comprehension
```
FIND src:comprehension
```
find any list comprehension
```
FIND [$A for $B in $C]
```
find any set comprehension
```
FIND {$A for $B in $C}
```
find any dictionary comprehension
```
FIND {$A: $B for $C in $D}
```

Example

foo = ["bar1","bar2","bar3"]

foo1 = [bar for bar in foo if "1" in bar]

<expr_stmt><expr><name>foo</name> <operator>=</operator> <array>[<expr><literal type="string">"bar1"</literal></expr>,<expr><literal type="string">"bar2"</literal></expr>,<expr><literal type="string">"bar3"</literal></expr>]</array></expr></expr_stmt>

<expr_stmt><expr><name>foo1</name> <operator>=</operator> <array>[<expr><name>bar</name></expr> <comprehension><for>for <control><expr><name>bar</name></expr> <range>in <expr><name>foo</name></expr></range></control></for> <if>if <condition><expr><literal type="string">"1"</literal> <operator>in</operator> <name>bar</name></expr></condition></if></comprehension>]</array></expr></expr_stmt>

dictionary

Element

<dictionary>

Subelements

<expr>
<comprehension>

XPath

srcQL

dictionary
```
//src:dictionary
```

find any dictionary
```
FIND src:dictionary
```
find any expression containing a dictionary
```
FIND {}
```
find any expresison containing a dictionary comprehension
```
FIND {$A: $B for $C in $D}
```

Example

summary = {
    "Name": "John Smith"
    "Gender": "Male"
    "Age": 23
    "Height": 68
}

print(summary["Name"])

<expr_stmt><expr><name>summary</name> <operator>=</operator> <dictionary>{
    <expr><literal type="string">"Name"</literal></expr>: <expr><literal type="string">"John Smith"</literal>
    <literal type="string">"Gender"</literal></expr>: <expr><literal type="string">"Male"</literal>
    <literal type="string">"Age"</literal></expr>: <expr><literal type="number">23</literal>
    <literal type="string">"Height"</literal></expr>: <expr><literal type="number">68</literal></expr>
}</dictionary></expr></expr_stmt>

<expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><name><name>summary</name><index>[<expr><literal type="string">"Name"</literal></expr>]</index></name></expr></argument>)</argument_list></call></expr></expr_stmt>

index

Element

<index>

Subelement

<expr>

XPath

index
```
//src:index
```

Example

items[0]

<expr_stmt><expr><name><name>items</name><index>[<expr><literal type="number">0</literal></expr>]</index></name></expr></expr_stmt>

set

Element

<set>

Subelements

<expr>
<comprehension>

XPath

srcQL

set
```
//src:set
```

find any set
```
FIND src:set
```
find any set comprehension
```
FIND {$A for $B in $C}
```

Example

mySet = {"red", "blue", "yellow", 1, 0, True, False, 2}

<expr_stmt><expr><name>mySet</name> <operator>=</operator> <set>{<expr><literal type="string">"red"</literal></expr>, <expr><literal type="string">"blue"</literal></expr>, <expr><literal type="string">"yellow"</literal></expr>, <expr><literal type="number">1</literal></expr>, <expr><literal type="number">0</literal></expr>, <expr><literal type="boolean">True</literal></expr>, <expr><literal type="boolean">False</literal></expr>, <expr><literal type="number">2</literal></expr>}</set></expr></expr_stmt>

tuple

Element

<tuple>

Subelements

<expr>

XPath

srcQL

tuple
```
//src:tuple
```

find any tuple (with or without parenthesis)
```
FIND src:tuple
```
find any expression containing a tuple
```
FIND ()
```
find any expression containing a tuple with at least two items
```
FIND ($A, $B)
```

Example

myTuple = ("red", "green", "blue", "blue")

<expr_stmt><expr><name>myTuple</name> <operator>=</operator> <tuple>(<expr><literal type="string">"red"</literal></expr>, <expr><literal type="string">"green"</literal></expr>, <expr><literal type="string">"blue"</literal></expr>, <expr><literal type="string">"blue"</literal></expr>)</tuple></expr></expr_stmt>

operator

Element

<operator>

XPath

srcQL

operator
```
//src:operator
```

find any operator
```
FIND src:operator
```
find any expression with a plus sign (+)
```
FIND +
```

Examples

lhsExpr + rhsExpr

<expr_stmt><expr><name>lhsExpr</name> <operator>+</operator> <name>rhsExpr</name></expr></expr_stmt>

lhsExpr = rhsExpr

<expr_stmt><expr><name>lhsExpr</name> <operator>=</operator> <name>rhsExpr</name></expr></expr_stmt>

attribute

Element

<attribute>

Subelement

<expr>

XPath

srcQL

attributes
```
//src:attribute
```

noreturn functions

//src:function[src:attribute/src:expr/src:name='noreturn']

find any attribute
```
FIND src:attribute
```
find all functions with at least one attribute
```
FIND @$E def $N():
```

Example

@method
def example():
    pass

<function><attribute>@<expr><name>method</name></expr></attribute>
def <name>example</name><parameter_list>()</parameter_list><block>:<block_content>
    <pass>pass</pass></block_content></block></function>

parameter list

Element

<parameter_list>

Subelement

<parameter>

XPath

srcQL

parameter list
```
//src:parameter_list
```

find any parameter list
```
FIND src:parameter_list
```

Examples

def function(foo):

<function>def <name>function</name><parameter_list>(<parameter><name>foo</name></parameter>)</parameter_list><block>:<block_content/></block></function>

def function(*collection):
    for arg in collection:
        print(arg)

<function>def <name>function</name><parameter_list>(<parameter type="args">*<name>collection</name></parameter>)</parameter_list><block>:<block_content>
    <for>for <control><expr><name>arg</name></expr> <range>in <expr><name>collection</name></expr></range></control><block>:<block_content>
        <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><name>arg</name></expr></argument>)</argument_list></call></expr></expr_stmt></block_content></block></for></block_content></block></function>

def func1():
  a = 1
  def func2():
    nonlocal a
    a = 2
  func2()
  return a

print(func1())

<function>def <name>func1</name><parameter_list>()</parameter_list><block>:<block_content>
  <expr_stmt><expr><name>a</name> <operator>=</operator> <literal type="number">1</literal></expr></expr_stmt>
  <function>def <name>func2</name><parameter_list>()</parameter_list><block>:<block_content>
    <nonlocal>nonlocal <name>a</name></nonlocal>
    <expr_stmt><expr><name>a</name> <operator>=</operator> <literal type="number">2</literal></expr></expr_stmt>
</block_content></block></function>  <expr_stmt><expr><call><name>func2</name><argument_list>()</argument_list></call></expr></expr_stmt>
  <return>return <expr><name>a</name></expr></return>
</block_content></block></function>
<expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><call><name>func1</name><argument_list>()</argument_list></call></expr></argument>)</argument_list></call></expr></expr_stmt>

generic property

Element

<parameter_list type="generic">

Subelement

<parameter>

XPath

srcQL

generic parameter list
```
//src:parameter_list[@type='generic']
```

find any generic parameter list

FIND src:parameter_list[@type="generic"]

Example

def func[a, b](x, y):

<function>def <name>func</name><parameter_list type="generic">[<parameter><name>a</name></parameter>, <parameter><name>b</name></parameter>]</parameter_list><parameter_list>(<parameter><name>x</name></parameter>, <parameter><name>y</name></parameter>)</parameter_list><block>:<block_content/></block></function>

throw

Element

<throw>

Subelements

<expr>
<from>

XPath

srcQL

uses of throw
```
//src:throw
```

find any raise statement
```
FIND src:throw
```
find any “raise … from” statement
```
FIND raise $A from $B
```

Examples

raise BaseException

<throw>raise <expr><name>BaseException</name></expr></throw>

raise RuntimeError("msg")

<throw>raise <expr><call><name>RuntimeError</name><argument_list>(<argument><expr><literal type="string">"msg"</literal></expr></argument>)</argument_list></call></expr></throw>

try

Element

<try>

Subelements

<block>
<catch>
<else>
<finally>

XPath

srcQL

try block
```
//src:try
```
try blocks with at least two catch blocks
```
//src:try[count(src:catch)>=2]
```

find any try block
```
FIND src:try
```
find any try block
```
FIND try
```
find any try statement with at least two catch blocks
```
FIND try: 
catch: 
catch:
```

Examples

try:

<try>try<block>:<block_content/></block></try>

class S:
    def __init__(self, arg : str)
        try:
            m(arg)
        except Exception:

<class>class <name>S</name><block>:<block_content>
    <function>def <name>__init__</name><parameter_list>(<parameter><name>self</name></parameter>, <parameter><name>arg</name> <annotation>: <expr><name>str</name></expr></annotation></parameter>)</parameter_list></function>
        <try>try<block>:<block_content>
            <expr_stmt><expr><call><name>m</name><argument_list>(<argument><expr><name>arg</name></expr></argument>)</argument_list></call></expr></expr_stmt>
        <catch>except <expr><name>Exception</name></expr><block>:<block_content>
</block_content></block></catch></block_content></block></try></block_content></block></class>

f(n : int):
    try:
        
    except Exception:

<expr_stmt><expr><call><name>f</name><argument_list>(<argument><expr><name>n</name> <annotation>: <expr><name>int</name></expr></annotation></expr></argument>)</argument_list></call><annotation>:</annotation></expr></expr_stmt>
    <try>try<block>:<block_content>
        
    <catch>except <expr><name>Exception</name></expr><block>:<block_content>
</block_content></block></catch></block_content></block></try>

except statement

Element

<catch>

Subelements

<alias>
<expr>
<block>
<name>

XPath

srcQL

catch blocks
```
//src:catch
```

find any except statement
```
FIND src:catch
```
find any except statements
```
FIND except
```
find any except statements that use Python 2 alternate aliasing syntax
```
FIND except $E, $N:
```

Examples

try:

except:

<try>try<block>:<block_content/></block>

<catch>except<block>:<block_content/></block></catch></try>

except:

<catch>except<block>:<block_content/></block></catch>

finally

Element

<finally>

Subelement

<block>

XPath

srcQL

finally block
```
//src:finally
```

find any finally statement
```
FIND src:finally
```
find any finally statement
```
FIND finally
```

Example

try:
  raise Exception("failed try")
except:
  print("except")
finally:
  print("finally")

<try>try<block>:<block_content>
  <throw>raise <expr><call><name>Exception</name><argument_list>(<argument><expr><literal type="string">"failed try"</literal></expr></argument>)</argument_list></call></expr></throw>
</block_content></block><catch>except<block>:<block_content>
  <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">"except"</literal></expr></argument>)</argument_list></call></expr></expr_stmt>
</block_content></block></catch><finally>finally<block>:<block_content>
  <expr_stmt><expr><call><name>print</name><argument_list>(<argument><expr><literal type="string">"finally"</literal></expr></argument>)</argument_list></call></expr></expr_stmt></block_content></block></finally></try>