Index

API symbols

`!!`:

utils: template `!!`[E: CatchableError](err: typedesc[E]; body): untyped

`!`:

`$?`:

descrobject: proc `$?`(descr: PyCommonMethodDescrObject): string

pow: proc `**`(self, other: PyComplexObject): PyComplexObject

rawMem: proc `=copy`[T](dest: var RtArray[T]; src: RtArray[T])

`=destroy`:

`=trace`:

rawMem: proc `=trace`[T](dest: var RtArray[T]; env: pointer)

`=wasMoved`:

rawMem: proc `=wasMoved`[T](self: var RtArray[T])

`>=`:

`>`:

floatobject: template `>`(self, casted: PyFloatObject): untyped

`@`:

rawMem: proc `@`[T](self: RtArray[T]): seq[T]

ops_bitwise: proc `not`(self: PyIntObject): PyIntObject

clib: proc abort()

abs:

absPyFloatObjectMagic:

floatobject: proc absPyFloatObjectMagic(selfNoCast: PyObject): PyObject

absPyInstanceObjectMagic:

classobject: proc absPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

absPyIntObjectMagic:

intobjectImpl: proc absPyIntObjectMagic(selfNoCast: PyObject): PyObject

absToUInt:

ops_toint: proc absToUInt(pyInt: PyIntObject; x: var SomeUnsignedInt): bool

add:

addaudithook:

addCompat:

compat: template addCompat[T](a, b: seq[T])

addFlags:

getters: proc addFlags(typ: PyTypeObject; flags: PY_TPFLAGS)

addOpCode:

codeobject: proc addOpCode(code: PyCodeObject; instr: tuple[opCode: OpCode, opArg: OpArg, lineNo: int])

addPybytearrayObjectMagic:

byteobjectsImpl: proc addPybytearrayObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

addPybytesObjectMagic:

byteobjectsImpl: proc addPybytesObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

addPyComplexObjectMagic:

complexobjectImpl: proc addPyComplexObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

addPyFloatObjectMagic:

floatobject: proc addPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

addPyInstanceObjectMagic:

classobject: proc addPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

addPyIntObjectMagic:

intobjectImpl: proc addPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

addPyListObjectMagic:

listobject: proc addPyListObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

addPySetObjectMethod:

setobject: proc addPySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

addPyStrObjectMagic:

meth: proc addPyStrObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

addPyTupleObjectMagic:

tupleobjectImpl: proc addPyTupleObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

addr0:

addr0: proc addr0[T](x: T): ptr

addr2location:

locApis: proc addr2location(code: PyCodeObject; addrq: int; start_line, start_column, end_line, end_column: var int): PyBaseErrorObject

addSource:

lexer: proc addSource(filePath, content: string)

addTp:

utils: template addTp(tp; basetype)

addTpOfBaseWithName:

utils: template addTpOfBaseWithName(name)

addTraceBack:

exceptionsImpl: proc addTraceBack(exc: PyBaseExceptionObject; fileName, funName: PyObject; lineNo, colNo: int; frame: PyObject; lastI = -1)

aintPyListObjectMethod:

listobject: proc aintPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

aiterPyInstanceObjectMagic:

classobject: proc aiterPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

akPyObject:

descrobject: const akPyObject

all:

iterops: proc all(iterable: PyObject): PyObject

allocated:

byteobjects: proc allocated(self: PyBytesWriter): int

allowSelfReadWhenBeforeRealWrite:

pyobject: template allowSelfReadWhenBeforeRealWrite(body)

andPyBoolObjectMagic:

boolobjectImpl: proc andPyBoolObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

andPyFrozenSetObjectMagic:

setobject: proc andPyFrozenSetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

andPyInstanceObjectMagic:

classobject: proc andPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

andPyIntObjectMagic:

intobjectImpl: proc andPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

andPySetObjectMagic:

setobject: proc andPySetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

anextPyInstanceObjectMagic:

classobject: proc anextPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

any:

iterops: proc any(iterable: PyObject): PyObject

ApiVersion:

modsupport: type ApiVersion

append:

appendPybytearrayObjectMethod:

byteobjectsImpl: proc appendPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

appendPyListObjectMethod:

listobject: proc appendPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

arg:

ast: proc arg(self: Asdlkeyword): AsdlIdentifier

argcount:

codeobject: proc argcount(self: PyCodeObject): int

argcountPyCodeObjectGetter:

codeobject: proc argcountPyCodeObjectGetter(selfNoCast: PyObject): PyObject

argcountPyCodeObjectSetter:

codeobject: proc argcountPyCodeObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

asAttrNameOrRetE:

attrsUtils: template asAttrNameOrRetE(name: PyObject): PyStrObject

asAttrNameOrSetExc:

attrsUtils: template asAttrNameOrSetExc(name: PyObject; exc: PyObject): PyStrObject

ascii:

unarys: proc ascii(us: PyObject): PyObject

Asdlalias:

asdl: type Asdlalias

AsdlaliasTk:

asdl: enum AsdlaliasTk

Asdlarg:

asdl: type Asdlarg

AsdlargTk:

asdl: enum AsdlargTk

Asdlarguments:

asdl: type Asdlarguments

AsdlargumentsTk:

asdl: enum AsdlargumentsTk

Asdlboolop:

asdl: type Asdlboolop

AsdlboolopTk:

asdl: enum AsdlboolopTk

Asdlcmpop:

asdl: type Asdlcmpop

AsdlcmpopTk:

asdl: enum AsdlcmpopTk

Asdlcomprehension:

asdl: type Asdlcomprehension

AsdlcomprehensionTk:

asdl: enum AsdlcomprehensionTk

AsdlConstant:

asdl: type AsdlConstant

Asdlexcepthandler:

asdl: type Asdlexcepthandler

AsdlexcepthandlerTk:

asdl: enum AsdlexcepthandlerTk

Asdlexpr:

asdl: type Asdlexpr

Asdlexpr_context:

asdl: type Asdlexpr_context

Asdlexpr_contextTk:

asdl: enum Asdlexpr_contextTk

AsdlexprTk:

asdl: enum AsdlexprTk

AsdlIdentifier:

asdl: type AsdlIdentifier

Asdlint:

asdl: type Asdlint

Asdlkeyword:

asdl: type Asdlkeyword

AsdlkeywordTk:

asdl: enum AsdlkeywordTk

Asdlmodl:

asdl: type Asdlmodl

AsdlmodlTk:

asdl: enum AsdlmodlTk

Asdloperator:

asdl: type Asdloperator

AsdloperatorTk:

asdl: enum AsdloperatorTk

Asdlslice:

asdl: type Asdlslice

AsdlsliceTk:

asdl: enum AsdlsliceTk

Asdlstmt:

asdl: type Asdlstmt

AsdlstmtTk:

asdl: enum AsdlstmtTk

Asdlunaryop:

asdl: type Asdlunaryop

AsdlunaryopTk:

asdl: enum AsdlunaryopTk

Asdlwithitem:

asdl: type Asdlwithitem

AsdlwithitemTk:

asdl: enum AsdlwithitemTk

asDouble:

as_integer_ratio:

floatobject: proc as_integer_ratio(self: PyFloatObject): tuple[num, den: int]

as_integer_ratioPyFloatObjectMethod:

floatobject: proc as_integer_ratioPyFloatObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

asList:

pycore_initconfig: proc asList(list: openArray[Str]): PyObject

asLongAndOverflow:

ops_toint: proc asLongAndOverflow(vv: PyIntObject; ovlf: var bool): int

asPyObjectBorrow:

attrsGeneric: template asPyObjectBorrow(r: PyStackRef): lent PyObject

asPyObjectSteal:

attrsGeneric: template asPyObjectSteal(r: PyStackRef): PyObject

AsPyParam:

paramsMeta: template AsPyParam(s: string)

asString:

ast:

AstAdd:

asdl: type AstAdd

AstAlias:

asdl: type AstAlias

AstAnd:

asdl: type AstAnd

AstAnnAssign:

asdl: type AstAnnAssign

AstArg:

asdl: type AstArg

AstArguments:

asdl: type AstArguments

AstAssert:

asdl: type AstAssert

AstAssign:

asdl: type AstAssign

AstAsyncFor:

asdl: type AstAsyncFor

AstAsyncFunctionDef:

asdl: type AstAsyncFunctionDef

AstAsyncWith:

asdl: type AstAsyncWith

AstAttribute:

asdl: type AstAttribute

AstAugAssign:

asdl: type AstAugAssign

AstAugLoad:

asdl: type AstAugLoad

AstAugStore:

asdl: type AstAugStore

AstAwait:

asdl: type AstAwait

AstBinOp:

asdl: type AstBinOp

AstBitAnd:

asdl: type AstBitAnd

AstBitOr:

asdl: type AstBitOr

AstBitXor:

asdl: type AstBitXor

AstBoolOp:

asdl: type AstBoolOp

AstBreak:

asdl: type AstBreak

AstCall:

asdl: type AstCall

AstClassDef:

asdl: type AstClassDef

AstCompare:

asdl: type AstCompare

AstComprehension:

asdl: type AstComprehension

AstConstant:

asdl: type AstConstant

AstContinue:

asdl: type AstContinue

AstDel:

asdl: type AstDel

AstDelete:

asdl: type AstDelete

AstDict:

asdl: type AstDict

AstDictComp:

asdl: type AstDictComp

AstDiv:

asdl: type AstDiv

AstEq:

asdl: type AstEq

AstExceptHandler:

asdl: type AstExceptHandler

AstExpr:

asdl: type AstExpr

AstExpression:

asdl: type AstExpression

AstExtSlice:

asdl: type AstExtSlice

AstFloorDiv:

asdl: type AstFloorDiv

AstFor:

asdl: type AstFor

AstFormattedValue:

asdl: type AstFormattedValue

AstFunctionDef:

asdl: type AstFunctionDef

AstGeneratorExp:

asdl: type AstGeneratorExp

AstGlobal:

asdl: type AstGlobal

AstGt:

asdl: type AstGt

AstGtE:

asdl: type AstGtE

AstIf:

asdl: type AstIf

AstIfExp:

asdl: type AstIfExp

AstImport:

asdl: type AstImport

AstImportFrom:

asdl: type AstImportFrom

AstIn:

asdl: type AstIn

AstIndex:

asdl: type AstIndex

AstInteractive:

asdl: type AstInteractive

AstInterpolation:

asdl: type AstInterpolation

AstInvert:

asdl: type AstInvert

AstIs:

asdl: type AstIs

AstIsNot:

asdl: type AstIsNot

AstJoinedStr:

asdl: type AstJoinedStr

AstKeyword:

asdl: type AstKeyword

AstLambda:

asdl: type AstLambda

AstList:

asdl: type AstList

AstListComp:

asdl: type AstListComp

AstLoad:

asdl: type AstLoad

AstLShift:

asdl: type AstLShift

AstLt:

asdl: type AstLt

AstLtE:

asdl: type AstLtE

AstMatMult:

asdl: type AstMatMult

AstMod:

asdl: type AstMod

AstModule:

asdl: type AstModule

AstMult:

asdl: type AstMult

AstName:

asdl: type AstName

AstNodeBase:

asdl: type AstNodeBase

AstNonlocal:

asdl: type AstNonlocal

AstNot:

asdl: type AstNot

AstNotEq:

asdl: type AstNotEq

AstNotIn:

asdl: type AstNotIn

AstOr:

asdl: type AstOr

AstParam:

asdl: type AstParam

AstPass:

asdl: type AstPass

AstPow:

asdl: type AstPow

AstRaise:

asdl: type AstRaise

AstReturn:

asdl: type AstReturn

AstRShift:

asdl: type AstRShift

AstSet:

asdl: type AstSet

AstSetComp:

asdl: type AstSetComp

AstSlice:

asdl: type AstSlice

AstStarred:

asdl: type AstStarred

AstStore:

asdl: type AstStore

AstSub:

asdl: type AstSub

AstSubscript:

asdl: type AstSubscript

AstSuite:

asdl: type AstSuite

AstTry:

asdl: type AstTry

AstTuple:

asdl: type AstTuple

AstUAdd:

asdl: type AstUAdd

AstUnaryOp:

asdl: type AstUnaryOp

AstUSub:

asdl: type AstUSub

AstWhile:

asdl: type AstWhile

AstWith:

asdl: type AstWith

AstWithitem:

asdl: type AstWithitem

AstYield:

asdl: type AstYield

AstYieldFrom:

asdl: type AstYieldFrom

asUTF8:

asUTF8AndSize:

atImpl:

utils: template atImpl(self; p)

audit:

audit: template audit(event: cstring; args: varargs[typed]): PyBaseErrorObject

audit_PyParser_AST:

apis: template audit_PyParser_AST(filename_obj)

audit_PyParser_AST_mayAsync:

apis: template audit_PyParser_AST_mayAsync(filename_obj)

auditPySysModuleObjectMethod:

sysmodule: proc auditPySysModuleObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

auditTuple:

audit: proc auditTuple(event: cstring; args: PyTupleObject): PyBaseErrorObject

awaitPyInstanceObjectMagic:

classobject: proc awaitPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

BaseExceptionToken:

basetok: enum BaseExceptionToken

basePyTypeObjectGetter:

typeobject: proc basePyTypeObjectGetter(selfNoCast: PyObject): PyObject

basePyTypeObjectSetter:

typeobject: proc basePyTypeObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

bin:

unarys: proc bin(n: PyObject): PyObject

binary_func:

op_helpers: template binary_func(op; magicop; opname)

BinaryMethod:

pyobjectBase: type BinaryMethod

bindFormatValue:

fstring: template bindFormatValue(T, selfToNimType)

bit_count:

bit_length: proc bit_count(self: PyIntObject): PyIntObject

bit_countPyIntObjectMethod:

intobjectImpl: proc bit_countPyIntObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

bit_length:

bit_length: proc bit_length(self: PyIntObject): PyIntObject

bit_lengthPyIntObjectMethod:

intobjectImpl: proc bit_lengthPyIntObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

bltinbuildClass:

bltinmodule: proc bltinbuildClass(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

bltin_clinicGen:

dispatch: macro bltin_clinicGen(def)

bltinDict:

builtindict: let bltinDict

bltindir:

bltinmodule: proc bltindir(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

BltinFunc:

pyobjectBase: type BltinFunc

bltinFuncParams:

pyobject: let bltinFuncParams

bltinhash:

bltinmodule: proc bltinhash(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

bltinid:

bltinmodule: proc bltinid(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

bltiniter:

bltinmodule: proc bltiniter(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

bltinlen:

bltinmodule: proc bltinlen(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

BltinMethod:

pyobjectBase: type BltinMethod

BltinMethodDef:

pyobjectBase: tuple BltinMethodDef

bltinrepr:

bltinmodule: proc bltinrepr(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

bltinTypes:

pyobjectBase: var bltinTypes

boolPyBoolObjectMagic:

boolobjectImpl: proc boolPyBoolObjectMagic(selfNoCast: PyObject): PyObject

boolPyComplexObjectMagic:

complexobjectImpl: proc boolPyComplexObjectMagic(selfNoCast: PyObject): PyObject

boolPyFloatObjectMagic:

floatobject: proc boolPyFloatObjectMagic(selfNoCast: PyObject): PyObject

boolPyInstanceObjectMagic:

classobject: proc boolPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

boolPyIntObjectMagic:

intobjectImpl: proc boolPyIntObjectMagic(selfNoCast: PyObject): PyObject

borrowFunc1s:

setobject: template borrowFunc1s(R; name; S; T: untyped = PyStrObject)

borrowFunc1sVoid:

setobject: template borrowFunc1sVoid(name; S; T: untyped = PyStrObject)

bufferNotImpl:

byteobjects: proc bufferNotImpl(): PyNotImplementedErrorObject

bufferPyInstanceObjectMagic:

classobject: proc bufferPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

BuildInfoCacheFile:

getbuildinfo: const BuildInfoCacheFile

builtin_abs:

unarys: proc builtin_abs(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_all:

iterops: proc builtin_all(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_any:

iterops: proc builtin_any(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_ascii:

unarys: proc builtin_ascii(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_bin:

unarys: proc builtin_bin(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_callable:

unarys: proc builtin_callable(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_chr:

unarys: proc builtin_chr(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_compile:

compile_eval_exec: proc builtin_compile(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtindelattr:

bltinmodule: proc builtindelattr(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_divmod:

ops: proc builtin_divmod(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_eval:

compile_eval_exec: proc builtin_eval(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_exec:

compile_eval_exec: proc builtin_exec(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_format:

unarys: proc builtin_format(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtingetattr:

bltinmodule: proc builtingetattr(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_globals:

globals_locals_vars: proc builtin_globals(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtinhasattr:

bltinmodule: proc builtinhasattr(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_hex:

unarys: proc builtin_hex(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_input:

io: proc builtin_input(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_locals:

globals_locals_vars: proc builtin_locals(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtinmax:

iterops: proc builtinmax(args: varargs[PyObject]; kwargs: PyObject): PyObject

builtinmin:

iterops: proc builtinmin(args: varargs[PyObject]; kwargs: PyObject): PyObject

builtinnext:

bltinmodule: proc builtinnext(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_oct:

unarys: proc builtin_oct(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_ord:

unarys: proc builtin_ord(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_pow:

ops: proc builtin_pow(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtinPrint:

io: proc builtinPrint(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_round:

ops: proc builtin_round(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtinsetattr:

bltinmodule: proc builtinsetattr(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_sort:

bltin_sort: proc builtin_sort(self: PyObject; args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_sorted:

iterops: proc builtin_sorted(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_sum:

sums: proc builtin_sum(args: openArray[PyObject]; kwargs: PyObject): PyObject

builtin_vars:

globals_locals_vars: proc builtin_vars(args: openArray[PyObject]; kwargs: PyObject): PyObject

bytes_join:

join: template bytes_join(S; sep; iterable: PyObject; mutable: bool)

bytesPybytearrayObjectMagic:

byteobjectsImpl: proc bytesPybytearrayObjectMagic(selfNoCast: PyObject): PyObject

bytesPybytesObjectMagic:

byteobjectsImpl: proc bytesPybytesObjectMagic(selfNoCast: PyObject): PyObject

bytesPyInstanceObjectMagic:

classobject: proc bytesPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

call:

callable:

unarys: proc callable(obj: PyObject): PyObject

calLen:

sliceobject: proc calLen(self: PySliceObject; res: var int): PyOverflowErrorObject

calLenOrRetOF:

sliceobject: template calLenOrRetOF(self: PySliceObject): int

callInplaceMagic:

pyobject: template callInplaceMagic(obj: PyObject; methodName1: untyped; arg1: PyObject; handleExcp = false): PyObject

callMagic:

callMethod:

callMethodArgs:

call: proc callMethodArgs(self: PyObject; name: PyStrObject; args: varargs[PyObject]): PyObject

callOnceFinalizerFromDealloc:

pyobjectBase: template callOnceFinalizerFromDealloc(self: var PyObjectObj; callBody)

callPyBoundMethodObjectMagic:

funcobjectImpl: proc callPyBoundMethodObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

callPyClassMethodDescrObjectMagic:

descrobjectImpl: proc callPyClassMethodDescrObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

callPyFunctionObjectMagic:

funcobjectImpl: proc callPyFunctionObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

callPyInstanceObjectMagic:

classobject: proc callPyInstanceObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

callPyMethodDescrObjectMagic:

descrobjectImpl: proc callPyMethodDescrObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

callPyNimFuncObjectMagic:

methodobject: proc callPyNimFuncObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

callPyTypeObjectMagic:

typeobject: proc callPyTypeObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

callTpDel:

pyobjectBase: proc callTpDel[Py: PyObject](tp: PyTypeObject; obj: var PyObjectObj): PyObject

capitalize:

capitalizePybytearrayObjectMethod:

byteobjectsImpl: proc capitalizePybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

capitalizePybytesObjectMethod:

byteobjectsImpl: proc capitalizePybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

capitalizePystrObjectMethod:

pkgs: proc capitalizePystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

cap_stop:

utils: proc cap_stop[P](self: P; stop: int): int

casefold:

pkgs: proc casefold(self: PyStrObject): PyStrObject

casefoldPystrObjectMethod:

pkgs: proc casefoldPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

castChar:

castChar: template castChar(i: SomeInteger | Rune): char

castSelf:

pyobject: macro castSelf(ObjectType: untyped; code: untyped): untyped

castTypeOrRetTE:

pyobject: template castTypeOrRetTE[O: PyObject](obj: PyObject; tp: typedesc[O]; extraArgs: varargs[untyped]): O

categoryName:

warningobject: proc categoryName(self: PyWarningMessageObject): string

cause_message:

pyerr_display: const cause_message

ceilDiv:

cellId:

symtable: proc cellId(ste: SymTableEntry; nameStr: PyStrObject): int

cellVarsToSeq:

symtable: proc cellVarsToSeq(ste: SymTableEntry): seq[PyStrObject]

center:

centerPybytearrayObjectMethod:

byteobjectsImpl: proc centerPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

centerPybytesObjectMethod:

byteobjectsImpl: proc centerPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

centerPystrObjectMethod:

pkgs: proc centerPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

Char:

str: type Char

characters_written:

exceptionsImpl: proc characters_written(self: PyOSErrorObject): PyObject

characters_writtenPyOSErrorObjectGetter:

exceptionsImpl: proc characters_writtenPyOSErrorObjectGetter(selfNoCast: PyObject): PyObject

characters_writtenPyOSErrorObjectSetter:

exceptionsImpl: proc characters_writtenPyOSErrorObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

CharsView:

byteobjects: type CharsView

charsView:

checkArgNum:

checkArgNumAtLeast:

baseapi: template checkArgNumAtLeast(expected: int; name = "")

checkArgNumAtMost:

baseapi: template checkArgNumAtMost(expected: int; name = "")

checkArgTypes:

pyobject: macro checkArgTypes(nameAndArg, code: untyped): untyped

checkCharRangeOrRetVE:

byteobjects: template checkCharRangeOrRetVE(value: int; errSubject = "byte")

checkConsistency:

stringobject: proc checkConsistency(self: PyStrObject; check_content: static[bool] = false): bool

checkTypeOrRetTE:

chkIdx:

utils: template chkIdx(i, L: int)

chr:

unarys: proc chr(c: PyObject): PyObject

clampedIndexOptArgAt:

args: template clampedIndexOptArgAt(args: openArray[PyObject]; i: int; def: int; size: int): int

classmethod_get:

descrobject: proc classmethod_get(self: PyObject; obj: PyObject; typ: PyObject = nil): PyObject

clear:

ops: proc clear(dict: PyDictObject)

clearIndent:

lexer: proc clearIndent(lexer: Lexer)

clearPybytearrayObjectMethod:

byteobjectsImpl: proc clearPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

clearPyDictObjectMethod:

dictobject: proc clearPyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

clearPyListObjectMethod:

listobject: proc clearPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

clearPySetObjectMethod:

setobject: proc clearPySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

clearTokens:

lexer: proc clearTokens(lexer: Lexer)

clinicGen:

dispatch: macro clinicGen(name; exported: static[bool]; def)

clinicGenAux:

dispatch: proc clinicGenAux(hasSelf: bool; genedPureNameStr: string; def: NimNode; exported = true): NimNode

clinicGenImplWithPrefix:

dispatch: proc clinicGenImplWithPrefix(prefix: string; def: NimNode): NimNode

clinicGenMeth:

dispatch: macro clinicGenMeth(name; exported: static[bool]; def)

clinicGenMethod:

dispatch: macro clinicGenMethod(typ; prc)

clinicGenMethodOfKind:

dispatch: macro clinicGenMethodOfKind(typ; kind: static[NPyMethodKind] = NPyMethodKind.Common; exceptions: untyped = []; prc)

clinicGenMethodRaises:

dispatch: macro clinicGenMethodRaises(typ; exceptions; prc)

clinicGenWithPrefix:

dispatch: macro clinicGenWithPrefix(prefix: static[string]; def)

cmpAscii:

stringobject: proc cmpAscii(self: PyStrObject; s: string): int

CmpOp:

opcode: enum CmpOp

CO:

compile: enum CO

code_adaptive:

codeobject: proc code_adaptive(self: PyCodeObject): PyBytesObject

codePyCodeObjectGetter:

codeobject: proc codePyCodeObjectGetter(selfNoCast: PyObject): PyObject

codePyCodeObjectSetter:

codeobject: proc codePyCodeObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

collectDeclaration:

symtable: proc collectDeclaration(st: SymTable; astRoot: Asdlmodl)

compile:

COMPLEX_BINOPimpl:

utils: template COMPLEX_BINOPimpl(methodName, op)

complex_pow:

pow: proc complex_pow(selfNoCast, other: PyObject): PyObject

conjugate:

complexobjectImpl: proc conjugate(self: PyComplexObject): PyComplexObject

conjugatePyComplexObjectMethod:

complexobjectImpl: proc conjugatePyComplexObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

cont:

lexerTypes: proc cont(lexer: Lexer): bool

contains:

containsOrIncl:

containsPybytearrayObjectMagic:

byteobjectsImpl: proc containsPybytearrayObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

containsPybytesObjectMagic:

byteobjectsImpl: proc containsPybytesObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

containsPyDictObjectMagic:

dictobject: proc containsPyDictObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

containsPyFrozenSetObjectMagic:

setobject: proc containsPyFrozenSetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

containsPyInstanceObjectMagic:

classobject: proc containsPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

containsPyListObjectMagic:

listobject: proc containsPyListObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

containsPySetObjectMagic:

setobject: proc containsPySetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

containsPyStrObjectMagic:

meth: proc containsPyStrObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

containsPyTupleObjectMagic:

tupleobject: proc containsPyTupleObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

contentTokenSet:

token: const contentTokenSet

context_message:

pyerr_display: const context_message

CONVERT_TO_DOUBLE:

utils: template CONVERT_TO_DOUBLE(obj, dbl)

convertVia:

paramsMeta: template convertVia(f: typed)

copyPybytearrayObjectMethod:

byteobjectsImpl: proc copyPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

copyPyDictObjectMethod:

dictobject: proc copyPyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

copyPyFrozenSetObjectMethod:

setobject: proc copyPyFrozenSetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

copyPyListObjectMethod:

listobject: proc copyPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

copyPySetObjectMethod:

setobject: proc copyPySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

countPybytearrayObjectMethod:

byteobjectsImpl: proc countPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

countPybytesObjectMethod:

byteobjectsImpl: proc countPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

countPyListObjectMethod:

listobject: proc countPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

countPyStrObjectMethod:

meth: proc countPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

countPyTupleObjectMethod:

tupleobjectImpl: proc countPyTupleObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

criticalRead:

critical_section: template criticalRead(self: PyObject; body)

criticalWrite:

critical_section: template criticalWrite(self: PyObject; body)

data:

stringobject: template data(self: PyStrObject): UnicodeVariant

declareIntFlag:

declarePyType:

pyobject: macro declarePyType(prototype, fields: untyped): untyped

decode_bytes_with_escapes:

string_parser: proc decode_bytes_with_escapes(L: lexerTypes.Lexer; s: string): string

decode_unicode_with_escapes:

string_parser: proc decode_unicode_with_escapes(L: lexerTypes.Lexer; s: string): string

dedentAll:

lexer: proc dedentAll(lexer: Lexer)

deepCopy:

macroutils: proc deepCopy(s: seq[NimNode]): seq[NimNode]

defdestroy:

del:

ops: proc del(dict: PyDictObject; key: PyObject)

delattrPyInstanceObjectMagic:

classobject: proc delattrPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

delitemImpl:

dictobject: proc delitemImpl(self: PyDictObject; other: PyObject): PyObject

delitemPybytearrayObjectMagic:

byteobjectsImpl: proc delitemPybytearrayObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

delitemPyDictObjectMagic:

dictobject: proc delitemPyDictObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

delitemPyInstanceObjectMagic:

classobject: proc delitemPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

delitemPyListObjectMagic:

listobject: proc delitemPyListObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

delPyInstanceObjectMagic:

classobject: proc delPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

descr_check:

descrobject: template descr_check(self, other)

destructor:

pyobjectBase: type destructor

DictError:

utils: object DictError

dictPyTypeObjectGetter:

typeobject: proc dictPyTypeObjectGetter(selfNoCast: PyObject): PyObject

dictPyTypeObjectSetter:

typeobject: proc dictPyTypeObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

difference:

differencePyFrozenSetObjectMethod:

setobject: proc differencePyFrozenSetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

differencePySetObjectMethod:

setobject: proc differencePySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

difference_updatePySetObjectMethod:

setobject: proc difference_updatePySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

digitCount:

bit_length: proc digitCount(v: PyIntObject): int

digitPyLong_DECIMAL_BASE:

decl: const digitPyLong_DECIMAL_BASE

discardPySetObjectMethod:

setobject: proc discardPySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

disjoint:

dispatchBin:

dispatch: template dispatchBin(op)

dispatchUnary:

dispatch: template dispatchUnary(op)

displayhook:

hooks: proc displayhook(o: PyObject): PyObject

displayhook_impl:

hooks: proc displayhook_impl(o: PyObject): PyBaseErrorObject

displayhookPySysModuleObjectMethod:

sysmodule: proc displayhookPySysModuleObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

divmod:

divmodNonZero:

divmodPyInstanceObjectMagic:

classobject: proc divmodPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

divmodPyIntObjectMagic:

intobjectImpl: proc divmodPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

divrem:

ops: proc divrem(a, b: PyIntObject): tuple[d, r: PyIntObject]

doBothKindOk:

stringobject: template doBothKindOk(self: UnicodeVariant; op): untyped

doclearPybytearrayObjectMethod:

byteobjectsImpl: proc doclearPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

doclearPyListObjectMethod:

listobject: proc doclearPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

doKindsWith2It:

stringobject: macro doKindsWith2It(self, other: UnicodeVariant; do0_3): untyped

dollarImpl:

utils: template dollarImpl(self: typed; getAccessor = selfAsAccessor)

do_mktuple:

modsupport: proc do_mktuple(args: NimNode): NimNode

doreadPybytearrayObjectMethod:

byteobjectsImpl: proc doreadPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

doreadPyListObjectMethod:

listobject: proc doreadPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

DUcomplexDUPyComplexObjectMethod:

complexobjectImpl: proc DUcomplexDUPyComplexObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

DUformatDUPyComplexObjectMethod:

complexobjectImpl: proc DUformatDUPyComplexObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

DUformatDUPyfloatObjectMethod:

toval: proc DUformatDUPyfloatObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

DUformatDUPyIntObjectMethod:

intobjectImpl: proc DUformatDUPyIntObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

DUformatDUPystrObjectMethod:

fstring: proc DUformatDUPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

DUreplaceDUPyNamespaceObjectMethod:

namespaceobject: proc DUreplaceDUPyNamespaceObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

DUroundDUPyFloatObjectMethod:

floatobject: proc DUroundDUPyFloatObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

DUroundDUPyIntObjectMethod:

intobjectImpl: proc DUroundDUPyIntObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

echoCompat:

compat: template echoCompat(content)

E_EOF:

apis: ParseErrorcode.E_EOF

endswith:

endswithPybytearrayObjectMethod:

byteobjectsImpl: proc endswithPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

endswithPybytesObjectMethod:

byteobjectsImpl: proc endswithPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

endswithPyStrObjectMethod:

meth: proc endswithPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

enter_FSTRING_EXPR:

lexerTypes: template enter_FSTRING_EXPR(tok: tokenizer_mode)

enterPyInstanceObjectMagic:

classobject: proc enterPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

E_OK:

apis: ParseErrorcode.E_OK

eqAscii:

stringobject: proc eqAscii(self: PyStrObject; s: string): bool

eqDefault:

default_generics: proc eqDefault(o1, o2: PyObject): PyObject

eqPyBoolObjectMagic:

boolobjectImpl: proc eqPyBoolObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPybytearrayObjectMagic:

byteobjectsImpl: proc eqPybytearrayObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPybytesObjectMagic:

byteobjectsImpl: proc eqPybytesObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPyComplexObjectMagic:

complexobjectImpl: proc eqPyComplexObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPyDictObjectMagic:

dictobject: proc eqPyDictObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPyFloatObjectMagic:

floatobject: proc eqPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPyFrozenSetObjectMagic:

setobject: proc eqPyFrozenSetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPyInstanceObjectMagic:

classobject: proc eqPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPyIntObjectMagic:

intobjectImpl: proc eqPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPyListObjectMagic:

listobject: proc eqPyListObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPyNamespaceObjectMagic:

namespaceobject: proc eqPyNamespaceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPySetObjectMagic:

setobject: proc eqPySetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPyStrObjectMagic:

meth: proc eqPyStrObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

eqPyTupleObjectMagic:

tupleobjectImpl: proc eqPyTupleObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

errArgNum:

baseapi: template errArgNum(argsLen, expected: int; name = "")

errEchoCompat:

compat: template errEchoCompat(content)

errEchoCompatNoRaise:

compat: template errEchoCompatNoRaise(s: string)

errorIfNot:

errorIfNotBool:

baseapi: template errorIfNotBool(pyObj: PyObject; methodName: string; doIt: untyped = retIt)

errorIfNotString:

baseapi: template errorIfNotString(pyObj: untyped; methodName: string; doIt: untyped = retIt)

eval:

compile_eval_exec: proc eval(source: PyObject; globals: PyObject = pyNone; locals: PyObject = pyNone): PyObject

evalCode:

evalFrame:

neval: proc evalFrame(f: PyFrameObject): PyObject

excepthook:

hooks: proc excepthook(exctype: PyObject; value: PyBaseErrorObject; traceback: PyObject)

excepthookPySysModuleObjectMethod:

sysmodule: proc excepthookPySysModuleObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

EXCEPTION_TB_HEADER_noNL:

traceback: const EXCEPTION_TB_HEADER_noNL

ExceptionToken:

basetok: enum ExceptionToken

exec:

compile_eval_exec: proc exec(source: PyObject; globals: PyObject = pyNone; locals: PyObject = pyNone; closure: PyObject = nil): PyObject

exit:

sysmodule: proc exit(status: PyObject = pyNone): PyObject

exitPyInstanceObjectMagic:

classobject: proc exitPyInstanceObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

exitPySysModuleObjectMethod:

sysmodule: proc exitPySysModuleObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

expandtabs:

expandtabsPybytearrayObjectMethod:

byteobjectsImpl: proc expandtabsPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

expandtabsPybytesObjectMethod:

byteobjectsImpl: proc expandtabsPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

expandtabsPystrObjectMethod:

pkgs: proc expandtabsPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

exportSincepy:

version: template exportSincepy(major, minor: int; sym: typed)

extend:

extendPybytearrayObjectMethod:

byteobjectsImpl: proc extendPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

extendPyListObjectMethod:

listobject: proc extendPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

extraObjAttrs:

extraTypedAttrs:

basetok: iterator extraTypedAttrs(tok: ExceptionToken | BaseExceptionToken): (NimNode, NimNode)

fastCall:

call: proc fastCall(callable: PyObject; args: openArray[PyObject]; kwnames: PyDictObject = nil): PyObject

fastCopyCharacters:

stringobject: proc fastCopyCharacters(dest: PyStrObject; dest_start: int; frm: PyStrObject; frm_start: int = 0; how_many: int = len(frm) - frm_start)

fatal_error:

pyerrors_fatal: proc fatal_error(header: static bool; prefix: cstring; msg: string; status: int)

feed:

npython: proc feed(py: var PyExecutor; input: string)

fileno:

fileio: proc fileno(f: File): cint

find:

findAll:

findAllWithoutMem:

sequtils: iterator findAllWithoutMem[A, B](key: typedesc; self: openArray[A]; sub: openArray[B]; start = 0; stop = self.len): int

findExe:

os_findExe_patch: proc findExe(exe: string; followSymlinks: bool = true; extensions: openArray[string] = ExeExts): string

findPybytearrayObjectMethod:

byteobjectsImpl: proc findPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

findPybytesObjectMethod:

byteobjectsImpl: proc findPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

findPyStrObjectMethod:

meth: proc findPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

findWithoutMem:

sequtils: proc findWithoutMem[A, B](key: typedesc; self: openArray[A]; sub: openArray[B]; start = 0; stop = self.len): int

finish:

finished:

parser: proc finished(node: ParseNode): bool

firstlineno:

codeobject: proc firstlineno(self: PyCodeObject): int

firstlinenoPyCodeObjectGetter:

codeobject: proc firstlinenoPyCodeObjectGetter(selfNoCast: PyObject): PyObject

firstlinenoPyCodeObjectSetter:

codeobject: proc firstlinenoPyCodeObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

flipSign:

signbit: template flipSign(self: PyIntObject): untyped

FloatInfodesc:

infos: const FloatInfodesc

FloatInfoType:

infos: var FloatInfoType

floatPyFloatObjectMagic:

floatobject: proc floatPyFloatObjectMagic(selfNoCast: PyObject): PyObject

floatPyInstanceObjectMagic:

classobject: proc floatPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

floatPyIntObjectMagic:

intobjectImpl: proc floatPyIntObjectMagic(selfNoCast: PyObject): PyObject

f_localsPyFrameObjectGetter:

frameobject: proc f_localsPyFrameObjectGetter(selfNoCast: PyObject): PyObject

f_localsPyFrameObjectSetter:

frameobject: proc f_localsPyFrameObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

floorDiv:

floatobject: proc floorDiv(a, b: PyFloatObject): PyFloatObject

floordiv:

floordivNonZero:

ops: proc floordivNonZero(a, b: PyIntObject): PyIntObject

floordivPyFloatObjectMagic:

floatobject: proc floordivPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

floordivPyInstanceObjectMagic:

classobject: proc floordivPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

floordivPyIntObjectMagic:

intobjectImpl: proc floordivPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

floorMod:

floatobject: proc floorMod(a, b: PyFloatObject): PyFloatObject

floormod:

floormodNonZero:

ops: proc floormodNonZero(a, b: PyIntObject): PyIntObject

flush_io:

fileio: proc flush_io()

format:

format_binary:

ops: proc format_binary(a: PyIntObject; base: uint8; alternate: bool; v: var string): PyBaseErrorObject

FormatPyObjectError:

strformat: object FormatPyObjectError

formatValue:

forMro:

pyobjectBase: template forMro(baseVar; tp: PyTypeObject; body)

forMroNoSelf:

pyobjectBase: template forMroNoSelf(baseVar; tp: PyTypeObject; body)

FRAME_OWNED_BY_FRAME_OBJECT:

pycore_interpframe_struct: PyInterpFrameOwner.FRAME_OWNED_BY_FRAME_OBJECT

FRAME_OWNED_BY_GENERATOR:

pycore_interpframe_struct: PyInterpFrameOwner.FRAME_OWNED_BY_GENERATOR

FRAME_OWNED_BY_INTERPRETER:

pycore_interpframe_struct: PyInterpFrameOwner.FRAME_OWNED_BY_INTERPRETER

FRAME_OWNED_BY_THREAD:

pycore_interpframe_struct: PyInterpFrameOwner.FRAME_OWNED_BY_THREAD

freeId:

symtable: proc freeId(ste: SymTableEntry; nameStr: PyStrObject): int

freeVarsToSeq:

symtable: proc freeVarsToSeq(ste: SymTableEntry): seq[PyStrObject]

frexp:

frexp: proc frexp(a: PyIntObject; e: var int64): float

fromBltinSyntaxError:

exceptionsImpl: proc fromBltinSyntaxError(e: SyntaxError; fileName: PyStrObject): PyExceptionObject

from_bytesPyIntObjectMethod:

intobjectImpl: proc from_bytesPyIntObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

fromhexPyFloatObjectMethod:

floatobject: proc fromhexPyFloatObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

fromkeysPyDictObjectMethod:

dictobjectImpl: proc fromkeysPyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

fromStr:

ops: proc fromStr[C: char](res: var PyIntObject; s: openArray[C]; nParsed: var int; base: int = 10): PyBaseErrorObject

FT:

pyatomic: template FT(x): untyped

geDefault:

default_generics: proc geDefault(o1, o2: PyObject): PyObject

genBuildCacheContent:

getbuildinfo: proc genBuildCacheContent(): string

genCollectMagics:

tupleobject: template genCollectMagics(items, implNameMagic, ofPyNameObject, PyNameObject, mutRead, mutReadRepr, seqToStr)

genFormat:

fstring: template genFormat(T)

genGetitem:

tupleobjectImpl: template genGetitem(nameStr, implNameMagic, newPyName, mutRead; getter: untyped = `[]`)

genMutableSequenceMethods:

listobject: template genMutableSequenceMethods(mapper, unmapper, S, Ele, beforeAppend)

genNumberVariant:

helpers: template genNumberVariant(Name, T)

genProperty:

genPyNimIteratorIter:

iterobject: template genPyNimIteratorIter(iterable): PyNimIteratorIterObject

genSequenceMagics:

tupleobjectImpl: template genSequenceMagics(nameStr, implNameMagic, implNameMethod; ofPyNameObject, PyNameObject, newPyName; mutRead, mutReadRepr; seqToStr; initWithDictUsingPairs = false): untyped

genToVal:

tovalsBase: template genToVal(T; fun)

genToValGeneric:

genTypeToAnyKind:

descrobject: template genTypeToAnyKind(PyObject)

gePyInstanceObjectMagic:

classobject: proc gePyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getattrPyInstanceObjectMagic:

classobject: proc getattrPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getBltinName:

getCharPtr:

byteobjects: proc getCharPtr(s: PyByteLike; i: int): ptr char

getClampedIndex:

getDict:

getDictUnsafe:

pyobjectBase: proc getDictUnsafe(obj: PyObject): PyObject

getFirstComplete:

neval_frame: proc getFirstComplete(frame: PyFrameObject): PyFrameObject

getFloatInfo:

infos: proc getFloatInfo(): PyObject

getFullyQualifiedName:

getFun:

pyobject: template getFun(obj: PyObject; methodName: untyped; handleExcp = false): untyped

getHashInfo:

infos: proc getHashInfo(): PyObject

getIndex:

idxHelpers: template getIndex(obj: PyIntObject; size: int; includeSize: static[bool] = false): int

getInfo:

token: proc getInfo(self: TokenNode): tuple[line, col: int]

getInt:

byteobjects: proc getInt(s: PyByteLike; i: int): PyIntObject

getIntInfo:

infos: proc getIntInfo(): PyObject

get_int_max_str_digitsPySysModuleObjectMethod:

sysmodule: proc get_int_max_str_digitsPySysModuleObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

getItem:

ops: proc getItem(dict: PyDictObject; key: PyObject): PyObject

getitemPybytearrayObjectMagic:

byteobjectsImpl: proc getitemPybytearrayObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getitemPybytesObjectMagic:

byteobjectsImpl: proc getitemPybytesObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getitemPyDictObjectMagic:

dictobject: proc getitemPyDictObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getitemPyDictProxyObjectMagic:

dictproxyobject: proc getitemPyDictProxyObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getitemPyFrameLocalsProxyObjectMagic:

frameobject: proc getitemPyFrameLocalsProxyObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getitemPyInstanceObjectMagic:

classobject: proc getitemPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getitemPyListObjectMagic:

listobject: proc getitemPyListObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getitemPyStrObjectMagic:

meth: proc getitemPyStrObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getitemPyTupleObjectMagic:

tupleobjectImpl: proc getitemPyTupleObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getItemRef:

GetItemRes:

optres: enum GetItemRes

getIterableWithCheck:

baseapi: template getIterableWithCheck(obj: PyObject): (PyObject, UnaryMethod)

getLen:

enumobject: proc getLen(ro: reversedobject; res: var int): PyBaseErrorObject

getLineNumber:

frameobject: proc getLineNumber(f: PyFrameObject): int

getLocals:

frameobject: proc getLocals(self: PyFrameObject): PyObject

getLocalsImpl:

frameobject: proc getLocalsImpl(self: PyFrameObject): PyObject

getMagic:

pyobject: template getMagic(obj: PyObject; methodName): untyped

get_max_str_digits:

ops: template get_max_str_digits(): int

getMode:

lexerTypes: proc getMode(lexer: Lexer): var tokenizer_mode

getNameAndArgTypes:

pyobject: proc getNameAndArgTypes(prototype: NimNode): (NimNode, NimNode)

getNameOfParam:

tovalUtils: proc getNameOfParam(p: NimNode): NimNode

getOptionalItem:

ops: proc getOptionalItem(dict: PyDictObject; key: PyObject): PyObject

getOptionalStr:

optionstr: proc getOptionalStr(argname: string; sobj: var PyObject; res: var string): PyBaseErrorObject

getPyBoundMethodObjectMagic:

funcobject: proc getPyBoundMethodObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getPyClassMethodDescrObjectMagic:

descrobject: proc getPyClassMethodDescrObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getPyDictObjectMethod:

dictobject: proc getPyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

getPyFunctionObjectMagic:

funcobject: proc getPyFunctionObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getPyGetSetDescrObjectMagic:

descrobject: proc getPyGetSetDescrObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getPyInstanceObjectMagic:

classobject: proc getPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getPyMemberDescrObjectMagic:

descrobjectImpl: proc getPyMemberDescrObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getPyMethodDescrObjectMagic:

descrobject: proc getPyMethodDescrObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getPyNameOfParamAsStr:

tovalUtils: proc getPyNameOfParamAsStr(n: NimNode): string

getPyParamConverterImpl:

tovalUtils: proc getPyParamConverterImpl(v: NimNode; isTyped = false): tuple[ varname, cvt: NimNode]

getPyPropertyObjectMagic:

descrobjectImpl: proc getPyPropertyObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getPyStaticMethodObjectMagic:

funcobject: proc getPyStaticMethodObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

getQualName:

getters: proc getQualName(typ: PyTypeObject): PyObject

getRawData:

rawMem: proc getRawData[T](self: var RtArray[T]): ptr UncheckedArray[T]

getRORawData:

rawMem: proc getRORawData[T](self: RtArray[T]): ptr UncheckedArray[T]

getScope:

symtable: proc getScope(ste: SymTableEntry; name: PyStrObject): Scope

getSliceItems:

sliceobject: proc getSliceItems[T](slice: PySliceObject; src: openArray[T]; dest: var (seq[T] | string)): PyObject

getSource:

GetSourceRes:

lexer: enum GetSourceRes

getSpecialFromOpArg:

ceval: proc getSpecialFromOpArg(opArg: int): PySpecialMethod

getSte:

symtable: proc getSte(st: SymTable; key: AstNodeBase): SymTableEntry

getSysPsEnc:

utils: proc getSysPsEnc(): tuple[ps1, ps2, encoding: string]

get_tb_next:

exceptionsImpl: proc get_tb_next(self: PyTracebackObject): PyObject

getTokenName:

base: proc getTokenName(excp: ExceptionToken | BaseExceptionToken): string

getTrackback:

traceback: proc getTrackback(self: PyBaseExceptionObject): PyObject

getTypeDict:

attrsGeneric: proc getTypeDict(obj: PyObject | PyObjectObj): PyDictObject

getval:

frameobject: proc getval(self: PyFrameObject; co: PyCodeObject; i: int): PyObject

getVersionInfo:

infos: proc getVersionInfo(): PyObject

getVersionString:

utils: proc getVersionString(verbose = false): string

gitidentifier:

getbuildinfo: proc gitidentifier(): string

gitversion:

getbuildinfo: proc gitversion(): string

globals:

globals_locals_vars: proc globals(): PyObject

GrammarNode:

grammar: type GrammarNode

grammarSet:

grammar: var grammarSet

grammarTokenList:

token: const grammarTokenList

GSR_LineNoNotSet:

lexer: GetSourceRes.GSR_LineNoNotSet

GSR_LineNoOutOfRange:

lexer: GetSourceRes.GSR_LineNoOutOfRange

GSR_NoSuchFile:

lexer: GetSourceRes.GSR_NoSuchFile

GSR_Success:

lexer: GetSourceRes.GSR_Success

gtDefault:

default_generics: proc gtDefault(o1, o2: PyObject): PyObject

gtPyFloatObjectMagic:

floatobject: proc gtPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

gtPyInstanceObjectMagic:

classobject: proc gtPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

handleBadHash:

helpers: template handleBadHash(res; body)

handleDelRes:

utils: proc handleDelRes(call: PyObject)

handleFormatExc:

handleHashExc:

handleValueErrorAsPyFormatExc:

fstring: template handleValueErrorAsPyFormatExc(body)

hasArg:

opcode: proc hasArg(opCode: OpCode): bool

hasArgSet:

opcode: const hasArgSet

hasCell:

symtable: proc hasCell(ste: SymTableEntry; nameStr: PyStrObject): bool

hasDict:

pyobjectBase: proc hasDict(obj: PyObject): bool

hasFeature:

getters: proc hasFeature(typ: PyTypeObject; flag: PY_TPFLAGS): bool

hasFree:

symtable: proc hasFree(ste: SymTableEntry; nameStr: PyStrObject): bool

hash:

hashCollection:

tupleobjectImpl: proc hashCollection[T: PyObject](self: T): Hash

hashCollectionImpl:

tupleobjectImpl: template hashCollectionImpl(items; hashForEmpty): Hash

hashDefault:

default_generics: proc hashDefault(self: PyObject): PyObject

HashInfodesc:

infos: const HashInfodesc

HashInfoType:

infos: var HashInfoType

hashPyBoolObjectMagic:

boolobjectImpl: proc hashPyBoolObjectMagic(selfNoCast: PyObject): PyObject

hashPybytearrayObjectMagic:

byteobjectsImpl: proc hashPybytearrayObjectMagic(selfNoCast: PyObject): PyObject

hashPybytesObjectMagic:

byteobjectsImpl: proc hashPybytesObjectMagic(selfNoCast: PyObject): PyObject

hashPyComplexObjectMagic:

complexobjectImpl: proc hashPyComplexObjectMagic(selfNoCast: PyObject): PyObject

hashPyDictObjectMagic:

dictobject: proc hashPyDictObjectMagic(selfNoCast: PyObject): PyObject

hashPyFloatObjectMagic:

floatobject: proc hashPyFloatObjectMagic(selfNoCast: PyObject): PyObject

hashPyFrozenSetObjectMagic:

setobject: proc hashPyFrozenSetObjectMagic(selfNoCast: PyObject): PyObject

hashPyInstanceObjectMagic:

classobject: proc hashPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

hashPyIntObjectMagic:

intobjectImpl: proc hashPyIntObjectMagic(selfNoCast: PyObject): PyObject

hashPyListObjectMagic:

listobject: proc hashPyListObjectMagic(selfNoCast: PyObject): PyObject

hashPySetObjectMagic:

setobject: proc hashPySetObjectMagic(selfNoCast: PyObject): PyObject

hashPyStrObjectMagic:

meth: proc hashPyStrObjectMagic(selfNoCast: PyObject): PyObject

hashPyTupleObjectMagic:

tupleobjectImpl: proc hashPyTupleObjectMagic(selfNoCast: PyObject): PyObject

hasKey:

hasOnlyStringKeys:

dictobject: proc hasOnlyStringKeys(dict: PyDictObject): bool

has_sq_item:

wraps: proc has_sq_item(self: PyObject): bool

has_sq_length:

wraps: proc has_sq_length(o: PyObject): bool

hasval:

frameobject: proc hasval(self: PyFrameObject; co: PyCodeObject; i: int): bool

header:

main: proc header(config: PyConfig)

helloPyListObjectMethod:

listobject: proc helloPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

hex:

hexPyFloatObjectMethod:

floatobject: proc hexPyFloatObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

iaddPybytearrayObjectMagic:

byteobjectsImpl: proc iaddPybytearrayObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

iaddPyInstanceObjectMagic:

classobject: proc iaddPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

iaddPyListObjectMagic:

listobject: proc iaddPyListObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

iandPyInstanceObjectMagic:

classobject: proc iandPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

id:

pyobjectBase: proc id(obj: PyObject): int

idStr:

pyobjectBase: proc idStr(obj: PyObject): string

ifloordivPyInstanceObjectMagic:

classobject: proc ifloordivPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

ifPyNimSequence_Check:

ilshiftPyInstanceObjectMagic:

classobject: proc ilshiftPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

IMAG:

hash_def: const IMAG

imag:

decl: template imag(self: PyComplexObject): float

ImageSuffixes:

lexer_utils: const ImageSuffixes

imagPyComplexObjectGetter:

complexobjectImpl: proc imagPyComplexObjectGetter(selfNoCast: PyObject): PyObject

imagPyComplexObjectSetter:

complexobjectImpl: proc imagPyComplexObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

imatmulPyInstanceObjectMagic:

classobject: proc imatmulPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

imodPyInstanceObjectMagic:

classobject: proc imodPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

implBltinFunc:

bltinmodule: macro implBltinFunc(prototype, pyName, body: untyped): untyped

implFormatValue:

fstring: template implFormatValue(T, impl)

implMethod:

implMethodGenTargetAndStartStop:

import_add_module:

imulPybytearrayObjectMagic:

byteobjectsImpl: proc imulPybytearrayObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

imulPyInstanceObjectMagic:

classobject: proc imulPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

imulPyListObjectMagic:

listobject: proc imulPyListObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

incl:

indentStack:

lexerTypes: proc indentStack(lexer: Lexer): var seq[int]

indexPybytearrayObjectMethod:

byteobjectsImpl: proc indexPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

indexPybytesObjectMethod:

byteobjectsImpl: proc indexPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

indexPyInstanceObjectMagic:

classobject: proc indexPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

indexPyListObjectMethod:

listobject: proc indexPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

indexPyStrObjectMethod:

meth: proc indexPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

indexPyTupleObjectMethod:

tupleobjectImpl: proc indexPyTupleObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

Indices:

sliceobjectImpl: tuple Indices

indices:

indicesPySliceObjectMethod:

sliceobjectImpl: proc indicesPySliceObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

INF:

hash_def: const INF

initAddressRange:

initBaseException:

initCore:

initInfo: proc initCore(sysdict: PyDictObject): PyBaseErrorObject

initFromObject:

byteobjects: proc initFromObject(self: PyByteArrayObject; x: PyObject): PyBaseErrorObject

initPyAttributeErrorObjectMagic:

exceptionsImpl: proc initPyAttributeErrorObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyBaseExceptionObjectMagic:

exceptionsImpl: proc initPyBaseExceptionObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPybytearrayObjectMagic:

byteobjectsImpl: proc initPybytearrayObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyBytesWriter:

initPyCompilerFlags:

compile: template initPyCompilerFlags(f = PyCFlag(0); fv = PyMinor): PyCompilerFlags

initPyDictObjectMagic:

dictobjectImpl: proc initPyDictObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyDictProxyObjectMagic:

dictproxyobject: proc initPyDictProxyObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyFrozenSetObjectMagic:

setobject: proc initPyFrozenSetObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyImportErrorObjectMagic:

exceptionsImpl: proc initPyImportErrorObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyInstanceObjectMagic:

classobject: proc initPyInstanceObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyListObjectMagic:

listobject: proc initPyListObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyMemberDef:

initPyNameErrorObjectMagic:

exceptionsImpl: proc initPyNameErrorObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyNamespaceObjectMagic:

namespaceobject: proc initPyNamespaceObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyOSErrorObjectMagic:

exceptionsImpl: proc initPyOSErrorObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyPropertyObjectMagic:

descrobject: proc initPyPropertyObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyRangeObjectMagic:

rangeobject: proc initPyRangeObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPySetObjectMagic:

setobject: proc initPySetObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyStaticMethodObjectMagic:

funcobject: proc initPyStaticMethodObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPySyntaxErrorObjectMagic:

exceptionsImpl: proc initPySyntaxErrorObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPySystemExitObjectMagic:

exceptionsImpl: proc initPySystemExitObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initPyTupleObjectMagic:

tupleobjectImpl: proc initPyTupleObjectMagic(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

initRtArray:

input:

io: proc input(prompt: PyObject = nil): PyObject

insertPybytearrayObjectMethod:

byteobjectsImpl: proc insertPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

insertPyListObjectMethod:

listobject: proc insertPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

INSIDE_FSTRING:

lexerTypes: template INSIDE_FSTRING(lexer: Lexer): bool

INSIDE_FSTRING_EXPR:

lexerTypes: template INSIDE_FSTRING_EXPR(tok: tokenizer_mode): bool

INSIDE_FSTRING_EXPR_AT_TOP:

lexerTypes: template INSIDE_FSTRING_EXPR_AT_TOP(tok: tokenizer_mode): bool

instantiationFuncname:

getfuncname: template instantiationFuncname(): cstring

interaction:

interactionPyFrozenSetObjectMethod:

setobject: proc interactionPyFrozenSetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

interactionPySetObjectMethod:

setobject: proc interactionPySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

interactiveHandleErrcode:

apis: template interactiveHandleErrcode(res: untyped = nil)

interactiveShell:

npython: proc interactiveShell()

InternalError:

utils: object InternalError

IntError:

utils: object IntError

InterruptError:

utils: object InterruptError

intersection_updatePySetObjectMethod:

setobject: proc intersection_updatePySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

IntFlag:

intflags: type IntFlag

IntInfodesc:

infos: const IntInfodesc

IntInfoType:

infos: var IntInfoType

intLikeOptArgAt:

args: template intLikeOptArgAt(args: seq[PyObject]; i: int; def: int): int

intPyFloatObjectMagic:

floatobject: proc intPyFloatObjectMagic(selfNoCast: PyObject): PyObject

intPyInstanceObjectMagic:

classobject: proc intPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

intPyIntObjectMagic:

intobjectImpl: proc intPyIntObjectMagic(selfNoCast: PyObject): PyObject

ints:

byteobjects: iterator ints(s: PyByteLike): PyIntObject

invertPyInstanceObjectMagic:

classobject: proc invertPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

invertPyIntObjectMagic:

intobjectImpl: proc invertPyIntObjectMagic(selfNoCast: PyObject): PyObject

iorPyDictObjectMagic:

dictobjectImpl: proc iorPyDictObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

iorPyInstanceObjectMagic:

classobject: proc iorPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

iPosCeil:

rangeLen: proc iPosCeil[I: SomeInteger](x: float): I

ipowPyInstanceObjectMagic:

classobject: proc ipowPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

irshiftPyInstanceObjectMagic:

classobject: proc irshiftPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

isalnum:

isalnumPybytearrayObjectMethod:

byteobjectsImpl: proc isalnumPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isalnumPybytesObjectMethod:

byteobjectsImpl: proc isalnumPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isalpha:

isalphaPybytearrayObjectMethod:

byteobjectsImpl: proc isalphaPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isalphaPybytesObjectMethod:

byteobjectsImpl: proc isalphaPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isalphaPystrObjectMethod:

pkgs: proc isalphaPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isascii:

isAscii:

stringobject: proc isAscii(self: PyStrObject): bool

isasciiPybytearrayObjectMethod:

byteobjectsImpl: proc isasciiPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isasciiPybytesObjectMethod:

byteobjectsImpl: proc isasciiPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isasciiPyStrObjectMethod:

meth: proc isasciiPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isatty:

fileio: proc isatty(fildes: cint): bool

isClass:

pyobjectBase: proc isClass(obj: PyObject): bool

isdecimal:

pkgs: proc isdecimal(self: PyStrObject): bool

isdecimalPystrObjectMethod:

pkgs: proc isdecimalPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isdigit:

isdigitPybytearrayObjectMethod:

byteobjectsImpl: proc isdigitPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isdigitPybytesObjectMethod:

byteobjectsImpl: proc isdigitPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isdisjointPyFrozenSetObjectMethod:

setobject: proc isdisjointPyFrozenSetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isdisjointPySetObjectMethod:

setobject: proc isdisjointPySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isEmpty:

str: proc isEmpty(s: Str): bool

isExceptionOf:

base: proc isExceptionOf(obj: PyObject; tk: ExceptionToken): bool

isExceptionType:

exceptionsImpl: proc isExceptionType(obj: PyObject): bool

isGrammarTerminator:

grammar: proc isGrammarTerminator(node: GrammarNode): bool

isIncomplete:

neval_frame: proc isIncomplete(frame: PyFrameObject): bool

is_integer:

floatobject: proc is_integer(self: PyFloatObject): bool

is_integerPyFloatObjectMethod:

floatobject: proc is_integerPyFloatObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

is_integerPyIntObjectMethod:

intobjectImpl: proc is_integerPyIntObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isKwOnlyStartImpl:

tovalUtils: proc isKwOnlyStartImpl(p: NimNode): bool

islower:

islowerPybytearrayObjectMethod:

byteobjectsImpl: proc islowerPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

islowerPybytesObjectMethod:

byteobjectsImpl: proc islowerPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

islowerPystrObjectMethod:

pkgs: proc islowerPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isNonTerminator:

token: proc isNonTerminator(node: Token): bool

isNotImplemented:

notimplementedobject: proc isNotImplemented(obj: PyObject): bool

isNull:

attrsGeneric: proc isNull(self: PyStackRef): bool

isOptional:

grammar: proc isOptional(node: GrammarNode): bool

isPyNone:

noneobject: proc isPyNone(o: PyObject): bool

isPyTrue:

boolobject: proc isPyTrue(self: PyBoolObject): bool

isPyTrueObj:

tupleobject: proc isPyTrueObj(obj: PyObject): bool

isspace:

isspacePybytearrayObjectMethod:

byteobjectsImpl: proc isspacePybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isspacePybytesObjectMethod:

byteobjectsImpl: proc isspacePybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isspacePystrObjectMethod:

pkgs: proc isspacePystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isStopIter:

base: proc isStopIter(obj: PyObject): bool

issubsetPyFrozenSetObjectMethod:

setobject: proc issubsetPyFrozenSetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

issubsetPySetObjectMethod:

setobject: proc issubsetPySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isSubtype:

subtype: proc isSubtype(a, b: PyTypeObject): bool

issupersetPyFrozenSetObjectMethod:

setobject: proc issupersetPyFrozenSetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

issupersetPySetObjectMethod:

setobject: proc issupersetPySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isTerminator:

token: proc isTerminator(node: Token): bool

isThrownException:

baseapi: template isThrownException(pyObj: PyObject): bool

istitle:

istitlePybytearrayObjectMethod:

byteobjectsImpl: proc istitlePybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

istitlePybytesObjectMethod:

byteobjectsImpl: proc istitlePybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

istitlePystrObjectMethod:

pkgs: proc istitlePystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isType:

pyobjectBase: proc isType(a, b: PyTypeObject): bool

isubPyInstanceObjectMagic:

classobject: proc isubPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

isupper:

isupperPybytearrayObjectMethod:

byteobjectsImpl: proc isupperPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isupperPybytesObjectMethod:

byteobjectsImpl: proc isupperPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

isupperPystrObjectMethod:

pkgs: proc isupperPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

items:

itemSize:

itemsPyDictObjectMethod:

dictobject: proc itemsPyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

iterInt:

sliceobjectImpl: iterator iterInt(ind: Indices[int]): int

iterMro:

pyobjectBase: iterator iterMro(tp: PyTypeObject): PyTypeObject

iternextPyEnumerateObjectMagic:

enumobject: proc iternextPyEnumerateObjectMagic(selfNoCast: PyObject): PyObject

iternextPyFilterObjectMagic:

iterobjects: proc iternextPyFilterObjectMagic(selfNoCast: PyObject): PyObject

iternextPyInstanceObjectMagic:

classobject: proc iternextPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

iternextPyMapObjectMagic:

iterobjects: proc iternextPyMapObjectMagic(selfNoCast: PyObject): PyObject

iternextPyNimIteratorIterObjectMagic:

iterobject: proc iternextPyNimIteratorIterObjectMagic(selfNoCast: PyObject): PyObject

iternextPyNimSeqIterObjectMagic:

iterobject: proc iternextPyNimSeqIterObjectMagic(selfNoCast: PyObject): PyObject

iternextPyRangeIterObjectMagic:

rangeobject: proc iternextPyRangeIterObjectMagic(selfNoCast: PyObject): PyObject

iternextPyReversedObjectMagic:

enumobject: proc iternextPyReversedObjectMagic(selfNoCast: PyObject): PyObject

iternextPySeqIterObjectMagic:

iterobject: proc iternextPySeqIterObjectMagic(selfNoCast: PyObject): PyObject

iternextPyStrIterObjectMagic:

meth: proc iternextPyStrIterObjectMagic(selfNoCast: PyObject): PyObject

iternextPyZipObjectMagic:

iterobjects: proc iternextPyZipObjectMagic(selfNoCast: PyObject): PyObject

iterPybytearrayObjectMagic:

byteobjectsImpl: proc iterPybytearrayObjectMagic(selfNoCast: PyObject): PyObject

iterPybytesObjectMagic:

byteobjectsImpl: proc iterPybytesObjectMagic(selfNoCast: PyObject): PyObject

iterPyDictObjectMagic:

dictobject: proc iterPyDictObjectMagic(selfNoCast: PyObject): PyObject

iterPyEnumerateObjectMagic:

enumobject: proc iterPyEnumerateObjectMagic(selfNoCast: PyObject): PyObject

iterPyFilterObjectMagic:

iterobjects: proc iterPyFilterObjectMagic(selfNoCast: PyObject): PyObject

iterPyFrameLocalsProxyObjectMagic:

frameobject: proc iterPyFrameLocalsProxyObjectMagic(selfNoCast: PyObject): PyObject

iterPyFrozenSetObjectMagic:

setobject: proc iterPyFrozenSetObjectMagic(selfNoCast: PyObject): PyObject

iterPyInstanceObjectMagic:

classobject: proc iterPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

iterPyListObjectMagic:

listobject: proc iterPyListObjectMagic(selfNoCast: PyObject): PyObject

iterPyMapObjectMagic:

iterobjects: proc iterPyMapObjectMagic(selfNoCast: PyObject): PyObject

iterPyNimIteratorIterObjectMagic:

iterobject: proc iterPyNimIteratorIterObjectMagic(selfNoCast: PyObject): PyObject

iterPyNimSeqIterObjectMagic:

iterobject: proc iterPyNimSeqIterObjectMagic(selfNoCast: PyObject): PyObject

iterPyRangeIterObjectMagic:

rangeobject: proc iterPyRangeIterObjectMagic(selfNoCast: PyObject): PyObject

iterPyRangeObjectMagic:

rangeobject: proc iterPyRangeObjectMagic(selfNoCast: PyObject): PyObject

iterPyReversedObjectMagic:

enumobject: proc iterPyReversedObjectMagic(selfNoCast: PyObject): PyObject

iterPySeqIterObjectMagic:

iterobject: proc iterPySeqIterObjectMagic(selfNoCast: PyObject): PyObject

iterPySetObjectMagic:

setobject: proc iterPySetObjectMagic(selfNoCast: PyObject): PyObject

iterPyStrIterObjectMagic:

meth: proc iterPyStrIterObjectMagic(selfNoCast: PyObject): PyObject

iterPyStrObjectMagic:

meth: proc iterPyStrObjectMagic(selfNoCast: PyObject): PyObject

iterPyTupleObjectMagic:

tupleobjectImpl: proc iterPyTupleObjectMagic(selfNoCast: PyObject): PyObject

iterPyZipObjectMagic:

iterobjects: proc iterPyZipObjectMagic(selfNoCast: PyObject): PyObject

itruedivPyInstanceObjectMagic:

classobject: proc itruedivPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

ixorPyInstanceObjectMagic:

classobject: proc ixorPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

join:

joinAsRunes:

stringobject: proc joinAsRunes(r: openArray[UnicodeVariant]; sep: string): seq[Rune]

joinPybytearrayObjectMethod:

byteobjectsImpl: proc joinPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

joinPybytesObjectMethod:

byteobjectsImpl: proc joinPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

joinPyStrObjectMethod:

meth: proc joinPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

jumpSet:

opcode: const jumpSet

keyError:

helpers: template keyError(other: PyObject): PyBaseErrorObject

keys:

keysPyDictObjectMethod:

dictobject: proc keysPyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

keysPyFrameLocalsProxyObjectMethod:

frameobject: proc keysPyFrameLocalsProxyObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

kind:

stringobject: template kind(self: PyStrObject): bool

kwonlyargcount:

codeobject: proc kwonlyargcount(self: PyCodeObject): int

kwonlyargcountPyCodeObjectGetter:

codeobject: proc kwonlyargcountPyCodeObjectGetter(selfNoCast: PyObject): PyObject

kwonlyargcountPyCodeObjectSetter:

codeobject: proc kwonlyargcountPyCodeObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

leDefault:

default_generics: proc leDefault(o1, o2: PyObject): PyObject

len:

lenPybytearrayObjectMagic:

byteobjectsImpl: proc lenPybytearrayObjectMagic(selfNoCast: PyObject): PyObject

lenPybytesObjectMagic:

byteobjectsImpl: proc lenPybytesObjectMagic(selfNoCast: PyObject): PyObject

lenPyDictObjectMagic:

dictobject: proc lenPyDictObjectMagic(selfNoCast: PyObject): PyObject

lenPyDictProxyObjectMagic:

dictproxyobject: proc lenPyDictProxyObjectMagic(selfNoCast: PyObject): PyObject

lenPyFrozenSetObjectMagic:

setobject: proc lenPyFrozenSetObjectMagic(selfNoCast: PyObject): PyObject

lenPyInstanceObjectMagic:

classobject: proc lenPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

lenPyListObjectMagic:

listobject: proc lenPyListObjectMagic(selfNoCast: PyObject): PyObject

lenPyRangeObjectMagic:

rangeobject: proc lenPyRangeObjectMagic(selfNoCast: PyObject): PyObject

lenPyReversedObjectMagic:

enumobject: proc lenPyReversedObjectMagic(selfNoCast: PyObject): PyObject

lenPySetObjectMagic:

setobject: proc lenPySetObjectMagic(selfNoCast: PyObject): PyObject

lenPyStrObjectMagic:

meth: proc lenPyStrObjectMagic(selfNoCast: PyObject): PyObject

lenPyTupleObjectMagic:

tupleobject: proc lenPyTupleObjectMagic(selfNoCast: PyObject): PyObject

lePyFrozenSetObjectMagic:

setobject: proc lePyFrozenSetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

lePyInstanceObjectMagic:

classobject: proc lePyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

lePySetObjectMagic:

setobject: proc lePySetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

Lexer:

lexerTypes: type Lexer

LexerEscaper:

lexerTypes: type LexerEscaper

lexString:

lexer: proc lexString(lexer: Lexer; input: string; mode = Mode.File)

lineNo:

lexerTypes: proc lineNo(lexer: Lexer): var int

ljust:

ljustPybytearrayObjectMethod:

byteobjectsImpl: proc ljustPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

ljustPybytesObjectMethod:

byteobjectsImpl: proc ljustPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

ljustPystrObjectMethod:

pkgs: proc ljustPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

localId:

symtable: proc localId(ste: SymTableEntry; localName: PyStrObject): int

locals:

globals_locals_vars: proc locals(): PyObject

localVarsToSeq:

symtable: proc localVarsToSeq(ste: SymTableEntry): seq[PyStrObject]

long_new_impl:

magicNew: proc long_new_impl(typ: PyTypeObject; x: PyObject; obase: PyObject): PyObject

lower:

lowerPybytearrayObjectMethod:

byteobjectsImpl: proc lowerPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

lowerPybytesObjectMethod:

byteobjectsImpl: proc lowerPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

lowerPystrObjectMethod:

pkgs: proc lowerPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

lshiftPyInstanceObjectMagic:

classobject: proc lshiftPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

lshiftPyIntObjectMagic:

intobjectImpl: proc lshiftPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

lstrip:

lstripPybytearrayObjectMethod:

byteobjectsImpl: proc lstripPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

lstripPybytesObjectMethod:

byteobjectsImpl: proc lstripPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

lstripPyStrObjectMethod:

meth: proc lstripPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

ltPyFloatObjectMagic:

floatobject: proc ltPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

ltPyInstanceObjectMagic:

classobject: proc ltPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

ltPyIntObjectMagic:

intobjectImpl: proc ltPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

MagicMethods:

pyobjectBase: tuple MagicMethods

magicNames:

pyobjectBase: const magicNames

magicNameStrs:

utils: var magicNameStrs

main:

npython: proc main(cmdline: string | seq[string] = ""; init: static[bool] = true)

Major:

versionInfo: const Major

matchExcp:

exceptionsImpl: proc matchExcp(target: PyTypeObject; current: PyExceptionObject): PyBoolObject

matchToken:

grammar: proc matchToken(node: GrammarNode; token: Token): bool

matmulPyInstanceObjectMagic:

classobject: proc matmulPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

MAX_UNICODE:

stringobject: const MAX_UNICODE

mayAsync:

compat: template mayAsync(def): untyped

mayAwait:

compat: template mayAwait(x): untyped

mayNewPromise:

compat: template mayNewPromise(x): untyped

MayPromise:

compat: type MayPromise

mayWaitFor:

compat: template mayWaitFor(x): untyped

methodMacroTmpl:

pyobject: macro methodMacroTmpl(name: untyped): untyped

Minor:

versionInfo: const Minor

Mode:

lexerTypes: enum Mode

modPyFloatObjectMagic:

floatobject: proc modPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

modPyInstanceObjectMagic:

classobject: proc modPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

modPyIntObjectMagic:

intobjectImpl: proc modPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

modulePyBoundMethodObjectGetter:

funcobject: proc modulePyBoundMethodObjectGetter(selfNoCast: PyObject): PyObject

modulePyBoundMethodObjectSetter:

funcobject: proc modulePyBoundMethodObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

modulePyTypeObjectGetter:

properties: proc modulePyTypeObjectGetter(selfNoCast: PyObject): PyObject

modulePyTypeObjectSetter:

properties: proc modulePyTypeObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

mro:

pyobjectBase: template mro(self: PyTypeObject): untyped

MS_WINDOWS:

defines: const MS_WINDOWS

mulPyComplexObjectMagic:

complexobjectImpl: proc mulPyComplexObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

mulPyFloatObjectMagic:

floatobject: proc mulPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

mulPyInstanceObjectMagic:

classobject: proc mulPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

mulPyIntObjectMagic:

intobjectImpl: proc mulPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

mulPyListObjectMagic:

listobject: proc mulPyListObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

mulPyTupleObjectMagic:

tupleobjectImpl: proc mulPyTupleObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

MULTIPLIER:

hash_def: const MULTIPLIER

mutable:

pyobject: macro mutable(kind, code: untyped): untyped

name:

moduleobject: proc name(self: PyModuleObject): PyStrObject

name=:

moduleobject: proc name=(self: PyModuleObject; name: PyStrObject)

nameAsStr:

attrsUtils: template nameAsStr()

nameId:

symtable: proc nameId(ste: SymTableEntry; nameStr: PyStrObject): int

namePyBoundMethodObjectGetter:

funcobject: proc namePyBoundMethodObjectGetter(selfNoCast: PyObject): PyObject

namePyBoundMethodObjectSetter:

funcobject: proc namePyBoundMethodObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

namePyModuleObjectGetter:

moduleobject: proc namePyModuleObjectGetter(selfNoCast: PyObject): PyObject

namePyModuleObjectSetter:

moduleobject: proc namePyModuleObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

namesToSeq:

symtable: proc namesToSeq(ste: SymTableEntry): seq[PyStrObject]

n_divmod:

ops: proc n_divmod(a, b: PyIntObject): tuple[d, m: PyIntObject]

neDefault:

default_generics: proc neDefault(o1, o2: PyObject): PyObject

negate:

signbit: template negate(self: PyIntObject): untyped

negative:

signbit: template negative(self: PyIntObject): untyped

negativePyComplexObjectMagic:

complexobjectImpl: proc negativePyComplexObjectMagic(selfNoCast: PyObject): PyObject

negativePyFloatObjectMagic:

floatobject: proc negativePyFloatObjectMagic(selfNoCast: PyObject): PyObject

negativePyInstanceObjectMagic:

classobject: proc negativePyInstanceObjectMagic(selfNoCast: PyObject): PyObject

negativePyIntObjectMagic:

intobjectImpl: proc negativePyIntObjectMagic(selfNoCast: PyObject): PyObject

nePyInstanceObjectMagic:

classobject: proc nePyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

newArithmeticError:

newAsciiUnicodeVariant:

newAsciiUnicodeVariantOfCap:

stringobject: proc newAsciiUnicodeVariantOfCap(cap: int): UnicodeVariant

newAssertionError:

newAstAdd:

asdl: proc newAstAdd(): AstAdd

newAstAlias:

asdl: proc newAstAlias(): AstAlias

newAstAnd:

asdl: proc newAstAnd(): AstAnd

newAstAnnAssign:

asdl: proc newAstAnnAssign(): AstAnnAssign

newAstArg:

asdl: proc newAstArg(): AstArg

newAstArguments:

asdl: proc newAstArguments(): AstArguments

newAstAssert:

asdl: proc newAstAssert(): AstAssert

newAstAssign:

asdl: proc newAstAssign(): AstAssign

newAstAsyncFor:

asdl: proc newAstAsyncFor(): AstAsyncFor

newAstAsyncFunctionDef:

asdl: proc newAstAsyncFunctionDef(): AstAsyncFunctionDef

newAstAsyncWith:

asdl: proc newAstAsyncWith(): AstAsyncWith

newAstAttribute:

asdl: proc newAstAttribute(): AstAttribute

newAstAugAssign:

asdl: proc newAstAugAssign(): AstAugAssign

newAstAugLoad:

asdl: proc newAstAugLoad(): AstAugLoad

newAstAugStore:

asdl: proc newAstAugStore(): AstAugStore

newAstAwait:

asdl: proc newAstAwait(): AstAwait

newAstBinOp:

asdl: proc newAstBinOp(): AstBinOp

newAstBitAnd:

asdl: proc newAstBitAnd(): AstBitAnd

newAstBitOr:

asdl: proc newAstBitOr(): AstBitOr

newAstBitXor:

asdl: proc newAstBitXor(): AstBitXor

newAstBoolOp:

asdl: proc newAstBoolOp(): AstBoolOp

newAstBreak:

asdl: proc newAstBreak(): AstBreak

newAstCall:

asdl: proc newAstCall(): AstCall

newAstClassDef:

asdl: proc newAstClassDef(): AstClassDef

newAstCompare:

asdl: proc newAstCompare(): AstCompare

newAstComprehension:

asdl: proc newAstComprehension(): AstComprehension

newAstConstant:

asdl: proc newAstConstant(): AstConstant

newAstContinue:

asdl: proc newAstContinue(): AstContinue

newAstDel:

asdl: proc newAstDel(): AstDel

newAstDelete:

asdl: proc newAstDelete(): AstDelete

newAstDict:

asdl: proc newAstDict(): AstDict

newAstDictComp:

asdl: proc newAstDictComp(): AstDictComp

newAstDiv:

asdl: proc newAstDiv(): AstDiv

newAstEq:

asdl: proc newAstEq(): AstEq

newAstExceptHandler:

asdl: proc newAstExceptHandler(): AstExceptHandler

newAstExpr:

asdl: proc newAstExpr(): AstExpr

newAstExpression:

asdl: proc newAstExpression(): AstExpression

newAstExtSlice:

asdl: proc newAstExtSlice(): AstExtSlice

newAstFloorDiv:

asdl: proc newAstFloorDiv(): AstFloorDiv

newAstFor:

asdl: proc newAstFor(): AstFor

newAstFormattedValue:

asdl: proc newAstFormattedValue(): AstFormattedValue

newAstFunctionDef:

asdl: proc newAstFunctionDef(): AstFunctionDef

newAstGeneratorExp:

asdl: proc newAstGeneratorExp(): AstGeneratorExp

newAstGlobal:

asdl: proc newAstGlobal(): AstGlobal

newAstGt:

asdl: proc newAstGt(): AstGt

newAstGtE:

asdl: proc newAstGtE(): AstGtE

newAstIf:

asdl: proc newAstIf(): AstIf

newAstIfExp:

asdl: proc newAstIfExp(): AstIfExp

newAstImport:

asdl: proc newAstImport(): AstImport

newAstImportFrom:

asdl: proc newAstImportFrom(): AstImportFrom

newAstIn:

asdl: proc newAstIn(): AstIn

newAstIndex:

asdl: proc newAstIndex(): AstIndex

newAstInteractive:

asdl: proc newAstInteractive(): AstInteractive

newAstInterpolation:

asdl: proc newAstInterpolation(): AstInterpolation

newAstInvert:

asdl: proc newAstInvert(): AstInvert

newAstIs:

asdl: proc newAstIs(): AstIs

newAstIsNot:

asdl: proc newAstIsNot(): AstIsNot

newAstJoinedStr:

asdl: proc newAstJoinedStr(): AstJoinedStr

newAstKeyword:

asdl: proc newAstKeyword(): AstKeyword

newAstLambda:

asdl: proc newAstLambda(): AstLambda

newAstList:

asdl: proc newAstList(): AstList

newAstListComp:

asdl: proc newAstListComp(): AstListComp

newAstLoad:

asdl: proc newAstLoad(): AstLoad

newAstLShift:

asdl: proc newAstLShift(): AstLShift

newAstLt:

asdl: proc newAstLt(): AstLt

newAstLtE:

asdl: proc newAstLtE(): AstLtE

newAstMatMult:

asdl: proc newAstMatMult(): AstMatMult

newAstMod:

asdl: proc newAstMod(): AstMod

newAstModule:

asdl: proc newAstModule(): AstModule

newAstMult:

asdl: proc newAstMult(): AstMult

newAstName:

asdl: proc newAstName(): AstName

newAstNonlocal:

asdl: proc newAstNonlocal(): AstNonlocal

newAstNot:

asdl: proc newAstNot(): AstNot

newAstNotEq:

asdl: proc newAstNotEq(): AstNotEq

newAstNotIn:

asdl: proc newAstNotIn(): AstNotIn

newAstOr:

asdl: proc newAstOr(): AstOr

newAstParam:

asdl: proc newAstParam(): AstParam

newAstPass:

asdl: proc newAstPass(): AstPass

newAstPow:

asdl: proc newAstPow(): AstPow

newAstRaise:

asdl: proc newAstRaise(): AstRaise

newAstReturn:

asdl: proc newAstReturn(): AstReturn

newAstRShift:

asdl: proc newAstRShift(): AstRShift

newAstSet:

asdl: proc newAstSet(): AstSet

newAstSetComp:

asdl: proc newAstSetComp(): AstSetComp

newAstSlice:

asdl: proc newAstSlice(): AstSlice

newAstStarred:

asdl: proc newAstStarred(): AstStarred

newAstStore:

asdl: proc newAstStore(): AstStore

newAstSub:

asdl: proc newAstSub(): AstSub

newAstSubscript:

asdl: proc newAstSubscript(): AstSubscript

newAstSuite:

asdl: proc newAstSuite(): AstSuite

newAstTry:

asdl: proc newAstTry(): AstTry

newAstTuple:

asdl: proc newAstTuple(): AstTuple

newAstUAdd:

asdl: proc newAstUAdd(): AstUAdd

newAstUnaryOp:

asdl: proc newAstUnaryOp(): AstUnaryOp

newAstUSub:

asdl: proc newAstUSub(): AstUSub

newAstWhile:

asdl: proc newAstWhile(): AstWhile

newAstWith:

asdl: proc newAstWith(): AstWith

newAstWithitem:

asdl: proc newAstWithitem(): AstWithitem

newAstYield:

asdl: proc newAstYield(): AstYield

newAstYieldFrom:

asdl: proc newAstYieldFrom(): AstYieldFrom

newAttributeError:

newBaseError:

newBaseException:

newBaseExceptionGroup:

newBltinPyType:

pyobjectBase: proc newBltinPyType[T: PyObject](name: string; base = pyObjectType): PyTypeObject

newBoundMethod:

funcobject: proc newBoundMethod(fun: PyFunctionObject; self: PyObject): PyBoundMethodObject

main: template newEvaluator(f): Evaluator

newFloatingPointError:

newGeneratorExit:

newIdentifier:

ast: proc newIdentifier(value: string): AsdlIdentifier

newImportError:

newIndexError:

newIndexTypeError:

sub: template newIndexTypeError(typeName: PyStrObject; obj: PyObject): untyped

newIOError:

newKeyboardInterrupt:

newModuleNotFoundError:

newNameError:

newNotImplementedError:

newOSError:

newOverflowError:

newProcTmpl:

utils: template newProcTmpl(excpName; tok: ExceptionToken | BaseExceptionToken)

newPyArithmeticErrorObjectMagic:

exceptionsImpl: proc newPyArithmeticErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyArithmeticErrorSimple:

base: proc newPyArithmeticErrorSimple(): PyArithmeticErrorObject

newPyAscii:

newPyAssertionErrorObjectMagic:

exceptionsImpl: proc newPyAssertionErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyAssertionErrorSimple:

base: proc newPyAssertionErrorSimple(): PyAssertionErrorObject

newPyAttributeErrorObjectMagic:

exceptionsImpl: proc newPyAttributeErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyAttributeErrorSimple:

base: proc newPyAttributeErrorSimple(): PyAttributeErrorObject

newPyBaseErrorObjectMagic:

exceptionsImpl: proc newPyBaseErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyBaseErrorSimple:

base: template newPyBaseErrorSimple(): untyped

newPyBaseExceptionGroupObjectMagic:

exceptionsImpl: proc newPyBaseExceptionGroupObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyBaseExceptionGroupSimple:

base: proc newPyBaseExceptionGroupSimple(): PyBaseExceptionGroupObject

newPyBaseExceptionObjectMagic:

exceptionsImpl: proc newPyBaseExceptionObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyBaseExceptionSimple:

base: proc newPyBaseExceptionSimple(): PyBaseExceptionObject

newPyBlockingIOErrorSimple:

sub: proc newPyBlockingIOErrorSimple(): PyBlockingIOErrorObject

newPyBool:

boolobject: proc newPyBool(b: bool): PyBoolObject

newPyBoolObjectMagic:

boolobjectImpl: proc newPyBoolObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyBoundMethodSimple:

funcobject: proc newPyBoundMethodSimple(): PyBoundMethodObject

newPyBrokenPipeErrorSimple:

sub: proc newPyBrokenPipeErrorSimple(): PyBrokenPipeErrorObject

newPyBufferErrorObjectMagic:

exceptionsImpl: proc newPyBufferErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyBufferErrorSimple:

base: proc newPyBufferErrorSimple(): PyBufferErrorObject

newPyBuiltinsModuleSimple:

bltinmodule_mod: proc newPyBuiltinsModuleSimple(): PyBuiltinsModuleObject

newPyByteArray:

newPyByteArraySimple:

byteobjects: proc newPyByteArraySimple(): PyByteArrayObject

newPyBytes:

newPybytesObjectMagic:

byteobjectsImpl: proc newPybytesObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyBytesSimple:

byteobjects: proc newPyBytesSimple(): PyBytesObject

newPyBytesWarningSimple:

warningobject: proc newPyBytesWarningSimple(): PyBytesWarningObject

newPyCell:

cellobject: proc newPyCell(content: PyObject): PyCellObject

newPyCellSimple:

cellobject: proc newPyCellSimple(): PyCellObject

newPyChildProcessErrorSimple:

sub: proc newPyChildProcessErrorSimple(): PyChildProcessErrorObject

newPyClassMethodDescr:

descrobject: proc newPyClassMethodDescr(t: PyTypeObject; meth: BltinMethod; name: PyStrObject): PyClassMethodDescrObject

newPyClassMethodDescrSimple:

descrobject: proc newPyClassMethodDescrSimple(): PyClassMethodDescrObject

newPyCode:

codeobject: proc newPyCode(codeName, fileName: PyStrObject; length: int): PyCodeObject

newPyCodeSimple:

codeobject: proc newPyCodeSimple(): PyCodeObject

newPyCommonMethodDescrSimple:

descrobject: proc newPyCommonMethodDescrSimple(): PyCommonMethodDescrObject

newPyComplex:

newPyComplexObjectMagic:

complexobjectImpl: proc newPyComplexObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyComplexSimple:

decl: proc newPyComplexSimple(): PyComplexObject

newPyConnectErrorSimple:

sub: proc newPyConnectErrorSimple(): PyConnectErrorObject

newPyConnectionAbortedErrorSimple:

sub: proc newPyConnectionAbortedErrorSimple(): PyConnectionAbortedErrorObject

newPyConnectionErrorSimple:

sub: proc newPyConnectionErrorSimple(): PyConnectionErrorObject

newPyConnectionRefusedErrorSimple:

sub: proc newPyConnectionRefusedErrorSimple(): PyConnectionRefusedErrorObject

newPyConnectionResetErrorSimple:

sub: proc newPyConnectionResetErrorSimple(): PyConnectionResetErrorObject

newPyDeprecationWarningSimple:

warningobject: proc newPyDeprecationWarningSimple(): PyDeprecationWarningObject

newPyDict:

newPyDictProxy:

dictproxyobject: proc newPyDictProxy(mapping: PyObject): PyObject

newPyDictProxySimple:

dictproxyobject: proc newPyDictProxySimple(): PyDictProxyObject

newPyDictSimple:

decl: proc newPyDictSimple(): PyDictObject

newPyEllipsisObjectMagic:

sliceobject: proc newPyEllipsisObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyEllipsisSimple:

sliceobject: proc newPyEllipsisSimple(): PyEllipsisObject

newPyEncodingWarningSimple:

warningobject: proc newPyEncodingWarningSimple(): PyEncodingWarningObject

newPyEnumerate:

newPyEnumerateObjectMagic:

enumobject: proc newPyEnumerateObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyEnumerateSimple:

enumobject: proc newPyEnumerateSimple(): PyEnumerateObject

newPyEOFErrorObjectMagic:

exceptionsImpl: proc newPyEOFErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyEOFErrorSimple:

base: proc newPyEOFErrorSimple(): PyEOFErrorObject

newPyExceptionSimple:

base: proc newPyExceptionSimple(): PyExceptionObject

newPyExecutor:

npython: proc newPyExecutor(filename = Fstdin): PyExecutor

newPyFileExistsErrorSimple:

sub: proc newPyFileExistsErrorSimple(): PyFileExistsErrorObject

newPyFileNotFoundErrorSimple:

sub: proc newPyFileNotFoundErrorSimple(): PyFileNotFoundErrorObject

newPyFilter:

newPyFilterObjectMagic:

iterobjects: proc newPyFilterObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyFilterSimple:

iterobjects: proc newPyFilterSimple(): PyFilterObject

newPyFloat:

newPyFloatFromhex:

floatobject: proc newPyFloatFromhex(s: PyStrObject): PyFloatObject

newPyFloatingPointErrorSimple:

sub: proc newPyFloatingPointErrorSimple(): PyFloatingPointErrorObject

newPyFloatObjectMagic:

floatobject: proc newPyFloatObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyFloatSimple:

decl: proc newPyFloatSimple(): PyFloatObject

newPyFrame:

newPyFrameLocalsProxy:

frameobject: proc newPyFrameLocalsProxy(frame: PyFrameObject): PyFrameLocalsProxyObject

newPyFrameLocalsProxyObjectMagic:

frameobject: proc newPyFrameLocalsProxyObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyFrameLocalsProxySimple:

frameobject: proc newPyFrameLocalsProxySimple(): PyFrameLocalsProxyObject

newPyFrameSimple:

frameobject: proc newPyFrameSimple(): PyFrameObject

newPyFrozenSet:

newPyFrozenSetSimple:

setobject: proc newPyFrozenSetSimple(): PyFrozenSetObject

newPyFunc:

funcobject: proc newPyFunc(name: PyStrObject; code: PyCodeObject; globals: PyDictObject; closure: PyTupleObject = nil; defaults: PyTupleObject = nil): PyFunctionObject

newPyFunctionSimple:

funcobject: proc newPyFunctionSimple(): PyFunctionObject

newPyFutureWarningSimple:

warningobject: proc newPyFutureWarningSimple(): PyFutureWarningObject

newPyGeneratorExitObjectMagic:

exceptionsImpl: proc newPyGeneratorExitObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyGeneratorExitSimple:

base: proc newPyGeneratorExitSimple(): PyGeneratorExitObject

newPyGetSetDescr:

descrobject: proc newPyGetSetDescr(getter: UnaryMethod; setter: BinaryMethod): PyObject

newPyGetSetDescrSimple:

descrobject: proc newPyGetSetDescrSimple(): PyGetSetDescrObject

newPyImportErrorObjectMagic:

exceptionsImpl: proc newPyImportErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyImportErrorSimple:

base: proc newPyImportErrorSimple(): PyImportErrorObject

newPyImportWarningSimple:

warningobject: proc newPyImportWarningSimple(): PyImportWarningObject

newPyIndentationErrorSimple:

sub: proc newPyIndentationErrorSimple(): PyIndentationErrorObject

newPyIndexErrorSimple:

sub: proc newPyIndexErrorSimple(): PyIndexErrorObject

newPyInstanceObjectMagic:

classobject: proc newPyInstanceObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyInstanceSimple:

classobject: proc newPyInstanceSimple(): PyInstanceObject

newPyInt:

newPyInteractiveSrc:

apis: proc newPyInteractiveSrc(): PyInteractiveSrcObject

newPyInteractiveSrcSimple:

apis: proc newPyInteractiveSrcSimple(): PyInteractiveSrcObject

newPyInterpolation:

newPyInterpolationObjectMagic:

interpolationobject: proc newPyInterpolationObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyInterpolationSimple:

interpolationobject: proc newPyInterpolationSimple(): PyInterpolationObject

newPyInterruptedErrorSimple:

sub: proc newPyInterruptedErrorSimple(): PyInterruptedErrorObject

newPyIntFromPtr:

newPyIntFromStr:

ops: proc newPyIntFromStr[C: char | Rune](s: openArray[C]): PyIntObject

newPyIntObjectMagic:

intobjectImpl: proc newPyIntObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyIntSimple:

decl: proc newPyIntSimple(): PyIntObject

newPyIOErrorSimple:

sub: proc newPyIOErrorSimple(): PyIOErrorObject

newPyIsADirectoryErrorSimple:

sub: proc newPyIsADirectoryErrorSimple(): PyIsADirectoryErrorObject

newPyKeyboardInterruptObjectMagic:

exceptionsImpl: proc newPyKeyboardInterruptObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyKeyboardInterruptSimple:

base: proc newPyKeyboardInterruptSimple(): PyKeyboardInterruptObject

newPyKeyErrorSimple:

sub: proc newPyKeyErrorSimple(): PyKeyErrorObject

newPyList:

newPyListSimple:

listobject: proc newPyListSimple(): PyListObject

newPyLockErrorObjectMagic:

exceptionsImpl: proc newPyLockErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyLockErrorSimple:

base: proc newPyLockErrorSimple(): PyLockErrorObject

newPyLookupErrorObjectMagic:

exceptionsImpl: proc newPyLookupErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyLookupErrorSimple:

base: proc newPyLookupErrorSimple(): PyLookupErrorObject

newPyMap:

newPyMapObjectMagic:

iterobjects: proc newPyMapObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyMapSimple:

iterobjects: proc newPyMapSimple(): PyMapObject

newPyMemberDescr:

descrobject: proc newPyMemberDescr(tp: PyTypeObject; member: PyMemberDef): PyMemberDescrObject

newPyMemberDescrSimple:

descrobject: proc newPyMemberDescrSimple(): PyMemberDescrObject

newPyMemoryErrorObjectMagic:

exceptionsImpl: proc newPyMemoryErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyMemoryErrorSimple:

base: proc newPyMemoryErrorSimple(): PyMemoryErrorObject

newPyMethodDescr:

newPyMethodDescrSimple:

descrobject: proc newPyMethodDescrSimple(): PyMethodDescrObject

newPyModule:

moduleobject: proc newPyModule(name: PyStrObject | string): PyModuleObject

newPyModuleDef:

moduledefs: proc newPyModuleDef(name: string; typ: PyTypeObject): PyModuleDef

newPyModuleImpl:

moduleobject: template newPyModuleImpl(T: typedesc[PyModuleObject]; typ: PyTypeObject; nam: PyStrObject | string; tp_alloc_may_exc = true)

newPyModuleNotFoundErrorSimple:

sub: proc newPyModuleNotFoundErrorSimple(): PyModuleNotFoundErrorObject

newPyModuleSimple:

moduleobject: proc newPyModuleSimple(): PyModuleObject

newPyNameErrorObjectMagic:

exceptionsImpl: proc newPyNameErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyNameErrorSimple:

base: proc newPyNameErrorSimple(): PyNameErrorObject

newPyNamespace:

newPyNamespaceSimple:

namespaceobject: proc newPyNamespaceSimple(): PyNamespaceObject

newPyNimFunc:

newPyNimFuncSimple:

methodobject: proc newPyNimFuncSimple(): PyNimFuncObject

newPyNimIteratorIter:

iterobject: proc newPyNimIteratorIter(itor: ItorPy): PyNimIteratorIterObject

newPyNimIteratorIterSimple:

iterobject: proc newPyNimIteratorIterSimple(): PyNimIteratorIterObject

newPyNimSeqIterSimple:

iterobject: proc newPyNimSeqIterSimple(): PyNimSeqIterObject

newPyNoneObjectMagic:

noneobjectImpl: proc newPyNoneObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyNotADirectoryErrorSimple:

sub: proc newPyNotADirectoryErrorSimple(): PyNotADirectoryErrorObject

newPyNotImplementedErrorSimple:

sub: proc newPyNotImplementedErrorSimple(): PyNotImplementedErrorObject

newPyNotImplementedObjectMagic:

notimplementedobject: proc newPyNotImplementedObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyOSErrorObjectMagic:

exceptionsImpl: proc newPyOSErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyOSErrorSimple:

base: proc newPyOSErrorSimple(): PyOSErrorObject

newPyOverflowErrorSimple:

sub: proc newPyOverflowErrorSimple(): PyOverflowErrorObject

newPyPendingDeprecationWarningSimple:

warningobject: proc newPyPendingDeprecationWarningSimple(): PyPendingDeprecationWarningObject

newPyPermissionErrorSimple:

sub: proc newPyPermissionErrorSimple(): PyPermissionErrorObject

newPyProcessLookupErrorSimple:

sub: proc newPyProcessLookupErrorSimple(): PyProcessLookupErrorObject

newPyPropertySimple:

descrobject: proc newPyPropertySimple(): PyPropertyObject

newPyPythonFinalizationErrorSimple:

sub: proc newPyPythonFinalizationErrorSimple(): PyPythonFinalizationErrorObject

newPyRangeIterSimple:

rangeobject: proc newPyRangeIterSimple(): PyRangeIterObject

newPyRangeSimple:

rangeobject: proc newPyRangeSimple(): PyRangeObject

newPyRecursionErrorSimple:

sub: proc newPyRecursionErrorSimple(): PyRecursionErrorObject

newPyReferenceErrorObjectMagic:

exceptionsImpl: proc newPyReferenceErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyReferenceErrorSimple:

base: proc newPyReferenceErrorSimple(): PyReferenceErrorObject

newPyResourceWarningSimple:

warningobject: proc newPyResourceWarningSimple(): PyResourceWarningObject

newPyReversed:

enumobject: proc newPyReversed(sequ: PyObject; typ = pyReversedObjectType): PyObject

newPyReversedObjectMagic:

enumobject: proc newPyReversedObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyReversedSimple:

enumobject: proc newPyReversedSimple(): PyReversedObject

newPyRuntimeErrorObjectMagic:

exceptionsImpl: proc newPyRuntimeErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyRuntimeErrorSimple:

base: proc newPyRuntimeErrorSimple(): PyRuntimeErrorObject

newPyRuntimeWarningSimple:

warningobject: proc newPyRuntimeWarningSimple(): PyRuntimeWarningObject

newPySeqIter:

newPySeqIterSimple:

iterobject: proc newPySeqIterSimple(): PySeqIterObject

newPySet:

newPySetSimple:

setobject: proc newPySetSimple(): PySetObject

newPySlice:

sliceobject: proc newPySlice(start, stop, step: PyObject): PyObject

newPySliceObjectMagic:

sliceobjectImpl: proc newPySliceObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPySliceSimple:

sliceobject: proc newPySliceSimple(): PySliceObject

newPyStaticMethod:

funcobject: proc newPyStaticMethod(callable: PyObject): PyStaticMethodObject

newPyStaticMethodSimple:

funcobject: proc newPyStaticMethodSimple(): PyStaticMethodObject

newPyStopAsyncIterationSimple:

base: template newPyStopAsyncIterationSimple(): untyped

newPyStopAsyncIterErrorObjectMagic:

exceptionsImpl: proc newPyStopAsyncIterErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyStopAsyncIterErrorSimple:

base: proc newPyStopAsyncIterErrorSimple(): PyStopAsyncIterErrorObject

newPyStopIterationSimple:

base: template newPyStopIterationSimple(): untyped

newPyStopIterErrorObjectMagic:

exceptionsImpl: proc newPyStopIterErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyStopIterErrorSimple:

base: proc newPyStopIterErrorSimple(): PyStopIterErrorObject

newPyStr:

newPyStrF:

strformat: template newPyStrF(str: string{lit}): PyStrObject

newPyString:

newPyStrIter:

meth: proc newPyStrIter(s: PyStrObject): PyStrIterObject

newPyStrIterSimple:

meth: proc newPyStrIterSimple(): PyStrIterObject

newPyStrObjectMagic:

meth: proc newPyStrObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyStrSimple:

stringobject: proc newPyStrSimple(): PyStrObject

newPyStructSequence:

newPyStructSequence_Desc:

newPyStructSequenceObjectMagic:

structseq: proc newPyStructSequenceObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyStructSequenceSimple:

structseq: proc newPyStructSequenceSimple(): PyStructSequenceObject

newPyStructSequenceType:

structseq: proc newPyStructSequenceType(desc: PyStructSequence_Desc; tp_flags = 0): PyObject

newPySyntaxErrorObjectMagic:

exceptionsImpl: proc newPySyntaxErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPySyntaxErrorSimple:

base: proc newPySyntaxErrorSimple(): PySyntaxErrorObject

newPySyntaxWarningSimple:

warningobject: proc newPySyntaxWarningSimple(): PySyntaxWarningObject

newPySysModuleSimple:

decl: proc newPySysModuleSimple(): PySysModuleObject

newPySystemErrorObjectMagic:

exceptionsImpl: proc newPySystemErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPySystemErrorSimple:

base: proc newPySystemErrorSimple(): PySystemErrorObject

newPySystemExitObjectMagic:

exceptionsImpl: proc newPySystemExitObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPySystemExitSimple:

base: proc newPySystemExitSimple(): PySystemExitObject

newPyTabErrorSimple:

sub: proc newPyTabErrorSimple(): PyTabErrorObject

newPythonFinalizationError:

newPyTimeoutErrorSimple:

sub: proc newPyTimeoutErrorSimple(): PyTimeoutErrorObject

newPyTraceback:

exceptionsImpl: proc newPyTraceback(t: TraceBack): PyTracebackObject

newPyTracebackSimple:

exceptionsImpl: proc newPyTracebackSimple(): PyTracebackObject

newPyTuple:

newPyTupleSimple:

decl: proc newPyTupleSimple(): PyTupleObject

newPyType:

pyobjectBase: proc newPyType[T: PyObject](name: string; base = pyObjectType): PyTypeObject

newPyTypeErrorObjectMagic:

exceptionsImpl: proc newPyTypeErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyTypeErrorSimple:

base: proc newPyTypeErrorSimple(): PyTypeErrorObject

newPyTypeObjectMagic:

typeobjectImpl: proc newPyTypeObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyUnboundLocalErrorSimple:

sub: proc newPyUnboundLocalErrorSimple(): PyUnboundLocalErrorObject

newPyUnicodeDecodeErrorSimple:

sub: proc newPyUnicodeDecodeErrorSimple(): PyUnicodeDecodeErrorObject

newPyUnicodeEncodeErrorSimple:

sub: proc newPyUnicodeEncodeErrorSimple(): PyUnicodeEncodeErrorObject

newPyUnicodeErrorSimple:

sub: proc newPyUnicodeErrorSimple(): PyUnicodeErrorObject

newPyUnicodeTranslateErrorSimple:

sub: proc newPyUnicodeTranslateErrorSimple(): PyUnicodeTranslateErrorObject

newPyUnicodeWarningSimple:

warningobject: proc newPyUnicodeWarningSimple(): PyUnicodeWarningObject

newPyUserWarningSimple:

warningobject: proc newPyUserWarningSimple(): PyUserWarningObject

newPyValueErrorObjectMagic:

exceptionsImpl: proc newPyValueErrorObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyValueErrorSimple:

base: proc newPyValueErrorSimple(): PyValueErrorObject

newPyWarningMessage:

warningobject: proc newPyWarningMessage(message: PyStrObject; category: PyTypeObject; filename: PyStrObject; lineno: PyIntObject; file: PyObject = pyNone; line: PyObject = pyNone; source: PyObject = pyNone): PyWarningMessageObject

newPyWarningMessageSimple:

warningobject: proc newPyWarningMessageSimple(): PyWarningMessageObject

newPyWarningSimple:

warningobject: proc newPyWarningSimple(): PyWarningObject

newPyZeroDivisionErrorSimple:

sub: proc newPyZeroDivisionErrorSimple(): PyZeroDivisionErrorObject

newPyZip:

newPyZipObjectMagic:

iterobjects: proc newPyZipObjectMagic(args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

newPyZipSimple:

iterobjects: proc newPyZipSimple(): PyZipObject

newRecursionError:

newReferenceError:

newRuntimeError:

newStopAsyncIterError:

newStopIterError:

newSymTable:

symtable: proc newSymTable(astRoot: Asdlmodl): SymTable

newSyntaxError:

newSystemError:

newSystemExit:

new_tokenizer_mode:

newTokenNode:

lexer: proc newTokenNode(token: Token; lineNo = -1; colNo = -1; content = ""): TokenNode

newTypeError:

newUnboundLocalError:

newUnicodeOrAsciiUnicodeVariant:

stringobject: proc newUnicodeOrAsciiUnicodeVariant(s: string | cstring): UnicodeVariant

newUnicodeUnicodeVariant:

newUnicodeUnicodeVariantOfCap:

stringobject: proc newUnicodeUnicodeVariantOfCap(cap: int): UnicodeVariant

newUnicodeVariant:

newValueError:

newZeroDivisionError:

next:

NFunc:

methodobject: enum NFunc

nil2none:

noneobject: proc nil2none(x: PyObject): PyObject

nlocals:

codeobject: proc nlocals(self: PyCodeObject): int

nlocalsPyCodeObjectGetter:

codeobject: proc nlocalsPyCodeObjectGetter(selfNoCast: PyObject): PyObject

nlocalsPyCodeObjectSetter:

codeobject: proc nlocalsPyCodeObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

none2nil:

noneobject: proc none2nil(x: PyObject): PyObject

noRelOff:

descrobject: template noRelOff(member: PyMemberDef; funcName: string)

noreturnUnreachable:

utils: proc noreturnUnreachable(msg = ShouldnotHere)

notPyBoolObjectMagic:

boolobjectImpl: proc notPyBoolObjectMagic(selfNoCast: PyObject): PyObject

notPyInstanceObjectMagic:

classobject: proc notPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

npyexportc:

nexportc: template npyexportc(def)

NPyExportcFlags:

nexportc_header: enum NPyExportcFlags

NPyExportcFlagsSet:

nexportc_header: type NPyExportcFlagsSet

npyexportcSet:

nexportc: template npyexportcSet(flags: NPyExportcFlagsSet; def)

NPyMethodKind:

pyobject: enum NPyMethodKind

NPYTHON_API_STRING:

modsupport: const NPYTHON_API_STRING

NPYTHON_API_VERSION:

modsupport: const NPYTHON_API_VERSION

NPythonAsyncReadline:

compat: const NPythonAsyncReadline

null_error:

helpers: proc null_error(): PyBaseErrorObject

numAsClampedIndexOrRetE:

args: template numAsClampedIndexOrRetE(x: PyObject; size: int): int

numAsIntOrRetE:

args: template numAsIntOrRetE(x: PyObject): int

numbits:

bit_length: proc numbits(v: PyIntObject): int64

object_init:

object_new_init: proc object_init(obj: PyObject; args: PyTupleObject; kwds: PyDictObject): PyObject

object_initwrap:

object_new_init: proc object_initwrap(self: PyObject; args: openArray[PyObject]; kwargs: PyObject): PyObject

object_new:

object_new_init: proc object_new(typ: PyTypeObject; args: PyTupleObject; kwds: PyDictObject): PyObject

object_newwrap:

object_new_init: proc object_newwrap(args: openArray[PyObject]; kwargs: PyObject): PyObject

oct:

unarys: proc oct(n: PyObject): PyObject

ofExactPyAnySet:

setobject: proc ofExactPyAnySet(x: PyObject): bool

ofExactPyArithmeticErrorObject:

base: proc ofExactPyArithmeticErrorObject(obj`gensym63: PyObject): bool

ofExactPyAssertionErrorObject:

base: proc ofExactPyAssertionErrorObject(obj`gensym130: PyObject): bool

ofExactPyAttributeErrorObject:

base: proc ofExactPyAttributeErrorObject(obj`gensym69: PyObject): bool

ofExactPyBaseExceptionGroupObject:

base: proc ofExactPyBaseExceptionGroupObject(obj`gensym210: PyObject): bool

ofExactPyBaseExceptionObject:

base: proc ofExactPyBaseExceptionObject(obj`gensym3: PyObject): bool

ofExactPyBlockingIOErrorObject:

sub: proc ofExactPyBlockingIOErrorObject(obj`gensym177: PyObject): bool

ofExactPyBoolObject:

boolobject: proc ofExactPyBoolObject(obj`gensym0: PyObject): bool

ofExactPyBoundMethodObject:

funcobject: proc ofExactPyBoundMethodObject(obj`gensym14: PyObject): bool

ofExactPyBrokenPipeErrorObject:

sub: proc ofExactPyBrokenPipeErrorObject(obj`gensym276: PyObject): bool

ofExactPyBufferErrorObject:

base: proc ofExactPyBufferErrorObject(obj`gensym77: PyObject): bool

ofExactPyBuiltinsModuleObject:

bltinmodule_mod: proc ofExactPyBuiltinsModuleObject(obj`gensym0: PyObject): bool

ofExactPyByteArrayObject:

byteobjects: proc ofExactPyByteArrayObject(obj`gensym5: PyObject): bool

ofExactPyBytesObject:

byteobjects: proc ofExactPyBytesObject(obj`gensym0: PyObject): bool

ofExactPyBytesWarningObject:

warningobject: proc ofExactPyBytesWarningObject(obj`gensym28: PyObject): bool

ofExactPyCellObject:

cellobject: proc ofExactPyCellObject(obj`gensym0: PyObject): bool

ofExactPyChildProcessErrorObject:

sub: proc ofExactPyChildProcessErrorObject(obj`gensym186: PyObject): bool

ofExactPyClassMethodDescrObject:

descrobject: proc ofExactPyClassMethodDescrObject(obj`gensym38: PyObject): bool

ofExactPyCodeObject:

codeobject: proc ofExactPyCodeObject(obj`gensym0: PyObject): bool

ofExactPyCommonMethodDescrObject:

descrobject: proc ofExactPyCommonMethodDescrObject(obj`gensym0: PyObject): bool

ofExactPyComplexObject:

decl: proc ofExactPyComplexObject(obj`gensym0: PyObject): bool

ofExactPyConnectErrorObject:

sub: proc ofExactPyConnectErrorObject(obj`gensym115: PyObject): bool

ofExactPyConnectionAbortedErrorObject:

sub: proc ofExactPyConnectionAbortedErrorObject(obj`gensym285: PyObject): bool

ofExactPyConnectionErrorObject:

sub: proc ofExactPyConnectionErrorObject(obj`gensym195: PyObject): bool

ofExactPyConnectionRefusedErrorObject:

sub: proc ofExactPyConnectionRefusedErrorObject(obj`gensym294: PyObject): bool

ofExactPyConnectionResetErrorObject:

sub: proc ofExactPyConnectionResetErrorObject(obj`gensym303: PyObject): bool

ofExactPyDeprecationWarningObject:

warningobject: proc ofExactPyDeprecationWarningObject(obj`gensym58: PyObject): bool

ofExactPyDictObject:

decl: proc ofExactPyDictObject(obj`gensym0: PyObject): bool

ofExactPyDictProxyObject:

dictproxyobject: proc ofExactPyDictProxyObject(obj`gensym0: PyObject): bool

ofExactPyEllipsisObject:

sliceobject: proc ofExactPyEllipsisObject(obj`gensym21: PyObject): bool

ofExactPyEncodingWarningObject:

warningobject: proc ofExactPyEncodingWarningObject(obj`gensym40: PyObject): bool

ofExactPyEnumerateObject:

enumobject: proc ofExactPyEnumerateObject(obj`gensym0: PyObject): bool

ofExactPyEOFErrorObject:

base: proc ofExactPyEOFErrorObject(obj`gensym181: PyObject): bool

ofExactPyExceptionObject:

base: proc ofExactPyExceptionObject(obj`gensym18: PyObject): bool

ofExactPyFileExistsErrorObject:

sub: proc ofExactPyFileExistsErrorObject(obj`gensym204: PyObject): bool

ofExactPyFileNotFoundErrorObject:

sub: proc ofExactPyFileNotFoundErrorObject(obj`gensym213: PyObject): bool

ofExactPyFilterObject:

iterobjects: proc ofExactPyFilterObject(obj`gensym383: PyObject): bool

ofExactPyFloatingPointErrorObject:

sub: proc ofExactPyFloatingPointErrorObject(obj`gensym25: PyObject): bool

ofExactPyFloatObject:

decl: proc ofExactPyFloatObject(obj`gensym0: PyObject): bool

ofExactPyFrameLocalsProxyObject:

frameobject: proc ofExactPyFrameLocalsProxyObject(obj`gensym24: PyObject): bool

ofExactPyFrameObject:

frameobject: proc ofExactPyFrameObject(obj`gensym0: PyObject): bool

ofExactPyFrozenSetObject:

setobject: proc ofExactPyFrozenSetObject(obj`gensym5: PyObject): bool

ofExactPyFunctionObject:

funcobject: proc ofExactPyFunctionObject(obj`gensym0: PyObject): bool

ofExactPyFutureWarningObject:

warningobject: proc ofExactPyFutureWarningObject(obj`gensym52: PyObject): bool

ofExactPyGeneratorExitObject:

base: proc ofExactPyGeneratorExitObject(obj`gensym198: PyObject): bool

ofExactPyGetSetDescrObject:

descrobject: proc ofExactPyGetSetDescrObject(obj`gensym64: PyObject): bool

ofExactPyImportErrorObject:

base: proc ofExactPyImportErrorObject(obj`gensym120: PyObject): bool

ofExactPyImportWarningObject:

warningobject: proc ofExactPyImportWarningObject(obj`gensym70: PyObject): bool

ofExactPyIndentationErrorObject:

sub: proc ofExactPyIndentationErrorObject(obj`gensym160: PyObject): bool

ofExactPyIndexErrorObject:

sub: proc ofExactPyIndexErrorObject(obj`gensym35: PyObject): bool

ofExactPyInstanceObject:

classobject: proc ofExactPyInstanceObject(obj`gensym0: PyObject): bool

ofExactPyInteractiveSrcObject:

apis: proc ofExactPyInteractiveSrcObject(obj`gensym0: PyObject): bool

ofExactPyInterpolationObject:

interpolationobject: proc ofExactPyInterpolationObject(obj`gensym0: PyObject): bool

ofExactPyInterruptedErrorObject:

sub: proc ofExactPyInterruptedErrorObject(obj`gensym222: PyObject): bool

ofExactPyIntObject:

decl: proc ofExactPyIntObject(obj`gensym0: PyObject): bool

ofExactPyIOErrorObject:

sub: proc ofExactPyIOErrorObject(obj`gensym105: PyObject): bool

ofExactPyIsADirectoryErrorObject:

sub: proc ofExactPyIsADirectoryErrorObject(obj`gensym231: PyObject): bool

ofExactPyKeyboardInterruptObject:

base: proc ofExactPyKeyboardInterruptObject(obj`gensym204: PyObject): bool

ofExactPyKeyErrorObject:

sub: proc ofExactPyKeyErrorObject(obj`gensym45: PyObject): bool

ofExactPyListObject:

listobject: proc ofExactPyListObject(obj`gensym0: PyObject): bool

ofExactPyLockErrorObject:

base: proc ofExactPyLockErrorObject(obj`gensym114: PyObject): bool

ofExactPyLookupErrorObject:

base: proc ofExactPyLookupErrorObject(obj`gensym95: PyObject): bool

ofExactPyMapObject:

iterobjects: proc ofExactPyMapObject(obj`gensym194: PyObject): bool

ofExactPyMemberDescrObject:

descrobject: proc ofExactPyMemberDescrObject(obj`gensym80: PyObject): bool

ofExactPyMemoryErrorObject:

base: proc ofExactPyMemoryErrorObject(obj`gensym157: PyObject): bool

ofExactPyMethodDescrObject:

descrobject: proc ofExactPyMethodDescrObject(obj`gensym5: PyObject): bool

ofExactPyModuleNotFoundErrorObject:

sub: proc ofExactPyModuleNotFoundErrorObject(obj`gensym95: PyObject): bool

ofExactPyModuleObject:

moduleobject: proc ofExactPyModuleObject(obj`gensym0: PyObject): bool

ofExactPyNameErrorObject:

base: proc ofExactPyNameErrorObject(obj`gensym49: PyObject): bool

ofExactPyNamespaceObject:

namespaceobject: proc ofExactPyNamespaceObject(obj`gensym0: PyObject): bool

ofExactPyNimFuncObject:

methodobject: proc ofExactPyNimFuncObject(obj`gensym0: PyObject): bool

ofExactPyNimIteratorIterObject:

iterobject: proc ofExactPyNimIteratorIterObject(obj`gensym21: PyObject): bool

ofExactPyNimSeqIterObject:

iterobject: proc ofExactPyNimSeqIterObject(obj`gensym0: PyObject): bool

ofExactPyNoneObject:

noneobject: proc ofExactPyNoneObject(obj`gensym0: PyObject): bool

ofExactPyNotADirectoryErrorObject:

sub: proc ofExactPyNotADirectoryErrorObject(obj`gensym240: PyObject): bool

ofExactPyNotImplementedErrorObject:

sub: proc ofExactPyNotImplementedErrorObject(obj`gensym65: PyObject): bool

ofExactPyNotImplementedObject:

pyobject: proc ofExactPyNotImplementedObject(obj`gensym117: PyObject): bool

ofExactPyOSErrorObject:

base: proc ofExactPyOSErrorObject(obj`gensym169: PyObject): bool

ofExactPyOverflowErrorObject:

sub: proc ofExactPyOverflowErrorObject(obj`gensym5: PyObject): bool

ofExactPyPendingDeprecationWarningObject:

warningobject: proc ofExactPyPendingDeprecationWarningObject(obj`gensym64: PyObject): bool

ofExactPyPermissionErrorObject:

sub: proc ofExactPyPermissionErrorObject(obj`gensym249: PyObject): bool

ofExactPyProcessLookupErrorObject:

sub: proc ofExactPyProcessLookupErrorObject(obj`gensym258: PyObject): bool

ofExactPyPropertyObject:

descrobject: proc ofExactPyPropertyObject(obj`gensym71: PyObject): bool

ofExactPyPythonFinalizationErrorObject:

sub: proc ofExactPyPythonFinalizationErrorObject(obj`gensym85: PyObject): bool

ofExactPyRangeIterObject:

rangeobject: proc ofExactPyRangeIterObject(obj`gensym24: PyObject): bool

ofExactPyRangeObject:

rangeobject: proc ofExactPyRangeObject(obj`gensym0: PyObject): bool

ofExactPyRecursionErrorObject:

sub: proc ofExactPyRecursionErrorObject(obj`gensym75: PyObject): bool

ofExactPyReferenceErrorObject:

base: proc ofExactPyReferenceErrorObject(obj`gensym89: PyObject): bool

ofExactPyResourceWarningObject:

warningobject: proc ofExactPyResourceWarningObject(obj`gensym76: PyObject): bool

ofExactPyReversedObject:

enumobject: proc ofExactPyReversedObject(obj`gensym117: PyObject): bool

ofExactPyRuntimeErrorObject:

base: proc ofExactPyRuntimeErrorObject(obj`gensym136: PyObject): bool

ofExactPyRuntimeWarningObject:

warningobject: proc ofExactPyRuntimeWarningObject(obj`gensym82: PyObject): bool

ofExactPySeqIterObject:

iterobject: proc ofExactPySeqIterObject(obj`gensym8: PyObject): bool

ofExactPySetObject:

setobject: proc ofExactPySetObject(obj`gensym0: PyObject): bool

ofExactPySliceObject:

sliceobject: proc ofExactPySliceObject(obj`gensym0: PyObject): bool

ofExactPyStaticMethodObject:

funcobject: proc ofExactPyStaticMethodObject(obj`gensym36: PyObject): bool

ofExactPyStopAsyncIterErrorObject:

base: proc ofExactPyStopAsyncIterErrorObject(obj`gensym108: PyObject): bool

ofExactPyStopIterErrorObject:

base: proc ofExactPyStopIterErrorObject(obj`gensym101: PyObject): bool

ofExactPyStrIterObject:

meth: proc ofExactPyStrIterObject(obj`gensym32: PyObject): bool

ofExactPyStrObject:

stringobject: proc ofExactPyStrObject(obj`gensym60: PyObject): bool

ofExactPyStructSequenceObject:

structseq: proc ofExactPyStructSequenceObject(obj`gensym0: PyObject): bool

ofExactPySyntaxErrorObject:

base: proc ofExactPySyntaxErrorObject(obj`gensym142: PyObject): bool

ofExactPySyntaxWarningObject:

warningobject: proc ofExactPySyntaxWarningObject(obj`gensym34: PyObject): bool

ofExactPySysModuleObject:

decl: proc ofExactPySysModuleObject(obj`gensym0: PyObject): bool

ofExactPySystemErrorObject:

base: proc ofExactPySystemErrorObject(obj`gensym163: PyObject): bool

ofExactPySystemExitObject:

base: proc ofExactPySystemExitObject(obj`gensym191: PyObject): bool

ofExactPyTabErrorObject:

sub: proc ofExactPyTabErrorObject(obj`gensym168: PyObject): bool

ofExactPyTimeoutErrorObject:

sub: proc ofExactPyTimeoutErrorObject(obj`gensym267: PyObject): bool

ofExactPyTracebackObject:

exceptionsImpl: proc ofExactPyTracebackObject(obj`gensym357: PyObject): bool

ofExactPyTupleObject:

decl: proc ofExactPyTupleObject(obj`gensym0: PyObject): bool

ofExactPyTypeErrorObject:

base: proc ofExactPyTypeErrorObject(obj`gensym57: PyObject): bool

ofExactPyUnboundLocalErrorObject:

sub: proc ofExactPyUnboundLocalErrorObject(obj`gensym55: PyObject): bool

ofExactPyUnicodeDecodeErrorObject:

sub: proc ofExactPyUnicodeDecodeErrorObject(obj`gensym136: PyObject): bool

ofExactPyUnicodeEncodeErrorObject:

sub: proc ofExactPyUnicodeEncodeErrorObject(obj`gensym144: PyObject): bool

ofExactPyUnicodeErrorObject:

sub: proc ofExactPyUnicodeErrorObject(obj`gensym123: PyObject): bool

ofExactPyUnicodeTranslateErrorObject:

sub: proc ofExactPyUnicodeTranslateErrorObject(obj`gensym152: PyObject): bool

ofExactPyUnicodeWarningObject:

warningobject: proc ofExactPyUnicodeWarningObject(obj`gensym46: PyObject): bool

ofExactPyUserWarningObject:

warningobject: proc ofExactPyUserWarningObject(obj`gensym88: PyObject): bool

ofExactPyValueErrorObject:

base: proc ofExactPyValueErrorObject(obj`gensym83: PyObject): bool

ofExactPyWarningMessageObject:

warningobject: proc ofExactPyWarningMessageObject(obj`gensym5: PyObject): bool

ofExactPyWarningObject:

warningobject: proc ofExactPyWarningObject(obj`gensym0: PyObject): bool

ofExactPyZeroDivisionErrorObject:

sub: proc ofExactPyZeroDivisionErrorObject(obj`gensym15: PyObject): bool

ofExactPyZipObject:

iterobjects: proc ofExactPyZipObject(obj`gensym0: PyObject): bool

ofPyAnySet:

setobject: proc ofPyAnySet(x: PyObject): bool

ofPyArithmeticErrorObject:

base: proc ofPyArithmeticErrorObject(obj`gensym63: PyObject): bool

ofPyAssertionErrorObject:

base: proc ofPyAssertionErrorObject(obj`gensym130: PyObject): bool

ofPyAttributeErrorObject:

base: proc ofPyAttributeErrorObject(obj`gensym69: PyObject): bool

ofPyBaseExceptionGroupObject:

base: proc ofPyBaseExceptionGroupObject(obj`gensym210: PyObject): bool

ofPyBaseExceptionObject:

base: proc ofPyBaseExceptionObject(obj`gensym3: PyObject): bool

ofPyBlockingIOErrorObject:

sub: proc ofPyBlockingIOErrorObject(obj`gensym177: PyObject): bool

ofPyBoolObject:

boolobject: proc ofPyBoolObject(obj`gensym0: PyObject): bool

ofPyBoundMethodObject:

funcobject: proc ofPyBoundMethodObject(obj`gensym14: PyObject): bool

ofPyBrokenPipeErrorObject:

sub: proc ofPyBrokenPipeErrorObject(obj`gensym276: PyObject): bool

ofPyBufferErrorObject:

base: proc ofPyBufferErrorObject(obj`gensym77: PyObject): bool

ofPyBuiltinsModuleObject:

bltinmodule_mod: proc ofPyBuiltinsModuleObject(obj`gensym0: PyObject): bool

ofPyByteArrayObject:

byteobjects: proc ofPyByteArrayObject(obj`gensym5: PyObject): bool

ofPyBytesObject:

byteobjects: proc ofPyBytesObject(obj`gensym0: PyObject): bool

ofPyBytesWarningObject:

warningobject: proc ofPyBytesWarningObject(obj`gensym28: PyObject): bool

ofPyCallable:

typeCheck: proc ofPyCallable(x: PyObject): bool

ofPyCellObject:

cellobject: proc ofPyCellObject(obj`gensym0: PyObject): bool

ofPyChildProcessErrorObject:

sub: proc ofPyChildProcessErrorObject(obj`gensym186: PyObject): bool

ofPyClassMethodDescrObject:

descrobject: proc ofPyClassMethodDescrObject(obj`gensym38: PyObject): bool

ofPyCodeObject:

codeobject: proc ofPyCodeObject(obj`gensym0: PyObject): bool

ofPyCommonMethodDescrObject:

descrobject: proc ofPyCommonMethodDescrObject(obj`gensym0: PyObject): bool

ofPyComplexObject:

decl: proc ofPyComplexObject(obj`gensym0: PyObject): bool

ofPyConnectErrorObject:

sub: proc ofPyConnectErrorObject(obj`gensym115: PyObject): bool

ofPyConnectionAbortedErrorObject:

sub: proc ofPyConnectionAbortedErrorObject(obj`gensym285: PyObject): bool

ofPyConnectionErrorObject:

sub: proc ofPyConnectionErrorObject(obj`gensym195: PyObject): bool

ofPyConnectionRefusedErrorObject:

sub: proc ofPyConnectionRefusedErrorObject(obj`gensym294: PyObject): bool

ofPyConnectionResetErrorObject:

sub: proc ofPyConnectionResetErrorObject(obj`gensym303: PyObject): bool

ofPyDeprecationWarningObject:

warningobject: proc ofPyDeprecationWarningObject(obj`gensym58: PyObject): bool

ofPyDictObject:

decl: proc ofPyDictObject(obj`gensym0: PyObject): bool

ofPyDictProxyObject:

dictproxyobject: proc ofPyDictProxyObject(obj`gensym0: PyObject): bool

ofPyEllipsisObject:

sliceobject: proc ofPyEllipsisObject(obj`gensym21: PyObject): bool

ofPyEncodingWarningObject:

warningobject: proc ofPyEncodingWarningObject(obj`gensym40: PyObject): bool

ofPyEnumerateObject:

enumobject: proc ofPyEnumerateObject(obj`gensym0: PyObject): bool

ofPyEOFErrorObject:

base: proc ofPyEOFErrorObject(obj`gensym181: PyObject): bool

ofPyExceptionClass:

ofPyExceptionInstance:

base: proc ofPyExceptionInstance(x: PyObject): bool

ofPyExceptionObject:

base: proc ofPyExceptionObject(obj`gensym18: PyObject): bool

ofPyFileExistsErrorObject:

sub: proc ofPyFileExistsErrorObject(obj`gensym204: PyObject): bool

ofPyFileNotFoundErrorObject:

sub: proc ofPyFileNotFoundErrorObject(obj`gensym213: PyObject): bool

ofPyFilterObject:

iterobjects: proc ofPyFilterObject(obj`gensym383: PyObject): bool

ofPyFloatingPointErrorObject:

sub: proc ofPyFloatingPointErrorObject(obj`gensym25: PyObject): bool

ofPyFloatObject:

decl: proc ofPyFloatObject(obj`gensym0: PyObject): bool

ofPyFrameLocalsProxyObject:

frameobject: proc ofPyFrameLocalsProxyObject(obj`gensym24: PyObject): bool

ofPyFrameObject:

frameobject: proc ofPyFrameObject(obj`gensym0: PyObject): bool

ofPyFrozenSetObject:

setobject: proc ofPyFrozenSetObject(obj`gensym5: PyObject): bool

ofPyFunctionObject:

funcobject: proc ofPyFunctionObject(obj`gensym0: PyObject): bool

ofPyFutureWarningObject:

warningobject: proc ofPyFutureWarningObject(obj`gensym52: PyObject): bool

ofPyGeneratorExitObject:

base: proc ofPyGeneratorExitObject(obj`gensym198: PyObject): bool

ofPyGetSetDescrObject:

descrobject: proc ofPyGetSetDescrObject(obj`gensym64: PyObject): bool

ofPyImportErrorObject:

base: proc ofPyImportErrorObject(obj`gensym120: PyObject): bool

ofPyImportWarningObject:

warningobject: proc ofPyImportWarningObject(obj`gensym70: PyObject): bool

ofPyIndentationErrorObject:

sub: proc ofPyIndentationErrorObject(obj`gensym160: PyObject): bool

ofPyIndexErrorObject:

sub: proc ofPyIndexErrorObject(obj`gensym35: PyObject): bool

ofPyInstanceObject:

classobject: proc ofPyInstanceObject(obj`gensym0: PyObject): bool

ofPyInteractiveSrcObject:

apis: proc ofPyInteractiveSrcObject(obj`gensym0: PyObject): bool

ofPyInterpolationObject:

interpolationobject: proc ofPyInterpolationObject(obj`gensym0: PyObject): bool

ofPyInterruptedErrorObject:

sub: proc ofPyInterruptedErrorObject(obj`gensym222: PyObject): bool

ofPyIntObject:

decl: proc ofPyIntObject(obj`gensym0: PyObject): bool

ofPyIOErrorObject:

sub: proc ofPyIOErrorObject(obj`gensym105: PyObject): bool

ofPyIsADirectoryErrorObject:

sub: proc ofPyIsADirectoryErrorObject(obj`gensym231: PyObject): bool

ofPyKeyboardInterruptObject:

base: proc ofPyKeyboardInterruptObject(obj`gensym204: PyObject): bool

ofPyKeyErrorObject:

sub: proc ofPyKeyErrorObject(obj`gensym45: PyObject): bool

ofPyListObject:

listobject: proc ofPyListObject(obj`gensym0: PyObject): bool

ofPyLockErrorObject:

base: proc ofPyLockErrorObject(obj`gensym114: PyObject): bool

ofPyLookupErrorObject:

base: proc ofPyLookupErrorObject(obj`gensym95: PyObject): bool

ofPyMapObject:

iterobjects: proc ofPyMapObject(obj`gensym194: PyObject): bool

ofPyMapping:

mapping: proc ofPyMapping(o: PyObject): bool

ofPyMemberDescrObject:

descrobject: proc ofPyMemberDescrObject(obj`gensym80: PyObject): bool

ofPyMemoryErrorObject:

base: proc ofPyMemoryErrorObject(obj`gensym157: PyObject): bool

ofPyMethodDescrObject:

descrobject: proc ofPyMethodDescrObject(obj`gensym5: PyObject): bool

ofPyModuleNotFoundErrorObject:

sub: proc ofPyModuleNotFoundErrorObject(obj`gensym95: PyObject): bool

ofPyModuleObject:

moduleobject: proc ofPyModuleObject(obj`gensym0: PyObject): bool

ofPyNameErrorObject:

base: proc ofPyNameErrorObject(obj`gensym49: PyObject): bool

ofPyNamespaceObject:

namespaceobject: proc ofPyNamespaceObject(obj`gensym0: PyObject): bool

ofPyNimFuncObject:

methodobject: proc ofPyNimFuncObject(obj`gensym0: PyObject): bool

ofPyNimIteratorIterObject:

iterobject: proc ofPyNimIteratorIterObject(obj`gensym21: PyObject): bool

ofPyNimSeqIterObject:

iterobject: proc ofPyNimSeqIterObject(obj`gensym0: PyObject): bool

ofPyNoneObject:

noneobject: proc ofPyNoneObject(obj`gensym0: PyObject): bool

ofPyNotADirectoryErrorObject:

sub: proc ofPyNotADirectoryErrorObject(obj`gensym240: PyObject): bool

ofPyNotImplementedErrorObject:

sub: proc ofPyNotImplementedErrorObject(obj`gensym65: PyObject): bool

ofPyNotImplementedObject:

pyobject: proc ofPyNotImplementedObject(obj`gensym117: PyObject): bool

ofPyOSErrorObject:

base: proc ofPyOSErrorObject(obj`gensym169: PyObject): bool

ofPyOverflowErrorObject:

sub: proc ofPyOverflowErrorObject(obj`gensym5: PyObject): bool

ofPyPendingDeprecationWarningObject:

warningobject: proc ofPyPendingDeprecationWarningObject(obj`gensym64: PyObject): bool

ofPyPermissionErrorObject:

sub: proc ofPyPermissionErrorObject(obj`gensym249: PyObject): bool

ofPyProcessLookupErrorObject:

sub: proc ofPyProcessLookupErrorObject(obj`gensym258: PyObject): bool

ofPyPropertyObject:

descrobject: proc ofPyPropertyObject(obj`gensym71: PyObject): bool

ofPyPythonFinalizationErrorObject:

sub: proc ofPyPythonFinalizationErrorObject(obj`gensym85: PyObject): bool

ofPyRangeIterObject:

rangeobject: proc ofPyRangeIterObject(obj`gensym24: PyObject): bool

ofPyRangeObject:

rangeobject: proc ofPyRangeObject(obj`gensym0: PyObject): bool

ofPyRecursionErrorObject:

sub: proc ofPyRecursionErrorObject(obj`gensym75: PyObject): bool

ofPyReferenceErrorObject:

base: proc ofPyReferenceErrorObject(obj`gensym89: PyObject): bool

ofPyResourceWarningObject:

warningobject: proc ofPyResourceWarningObject(obj`gensym76: PyObject): bool

ofPyReversedObject:

enumobject: proc ofPyReversedObject(obj`gensym117: PyObject): bool

ofPyRuntimeErrorObject:

base: proc ofPyRuntimeErrorObject(obj`gensym136: PyObject): bool

ofPyRuntimeWarningObject:

warningobject: proc ofPyRuntimeWarningObject(obj`gensym82: PyObject): bool

ofPySeqIterObject:

iterobject: proc ofPySeqIterObject(obj`gensym8: PyObject): bool

ofPySequence:

sequence: template ofPySequence(o: PyObject): bool

ofPySetObject:

setobject: proc ofPySetObject(obj`gensym0: PyObject): bool

ofPySliceObject:

sliceobject: proc ofPySliceObject(obj`gensym0: PyObject): bool

ofPyStaticMethodObject:

funcobject: proc ofPyStaticMethodObject(obj`gensym36: PyObject): bool

ofPyStopAsyncIterErrorObject:

base: proc ofPyStopAsyncIterErrorObject(obj`gensym108: PyObject): bool

ofPyStopIterErrorObject:

base: proc ofPyStopIterErrorObject(obj`gensym101: PyObject): bool

ofPyStrIterObject:

meth: proc ofPyStrIterObject(obj`gensym32: PyObject): bool

ofPyStrObject:

stringobject: proc ofPyStrObject(obj`gensym60: PyObject): bool

ofPyStructSequenceObject:

structseq: proc ofPyStructSequenceObject(obj`gensym0: PyObject): bool

ofPySyntaxErrorObject:

base: proc ofPySyntaxErrorObject(obj`gensym142: PyObject): bool

ofPySyntaxWarningObject:

warningobject: proc ofPySyntaxWarningObject(obj`gensym34: PyObject): bool

ofPySysModuleObject:

decl: proc ofPySysModuleObject(obj`gensym0: PyObject): bool

ofPySystemErrorObject:

base: proc ofPySystemErrorObject(obj`gensym163: PyObject): bool

ofPySystemExitObject:

base: proc ofPySystemExitObject(obj`gensym191: PyObject): bool

ofPyTabErrorObject:

sub: proc ofPyTabErrorObject(obj`gensym168: PyObject): bool

ofPyTimeoutErrorObject:

sub: proc ofPyTimeoutErrorObject(obj`gensym267: PyObject): bool

ofPyTracebackObject:

exceptionsImpl: proc ofPyTracebackObject(obj`gensym357: PyObject): bool

ofPyTupleObject:

decl: proc ofPyTupleObject(obj`gensym0: PyObject): bool

ofPyTypeErrorObject:

base: proc ofPyTypeErrorObject(obj`gensym57: PyObject): bool

ofPyTypeObject:

pyobjectBase: proc ofPyTypeObject(obj: PyObject): bool

ofPyUnboundLocalErrorObject:

sub: proc ofPyUnboundLocalErrorObject(obj`gensym55: PyObject): bool

ofPyUnicodeDecodeErrorObject:

sub: proc ofPyUnicodeDecodeErrorObject(obj`gensym136: PyObject): bool

ofPyUnicodeEncodeErrorObject:

sub: proc ofPyUnicodeEncodeErrorObject(obj`gensym144: PyObject): bool

ofPyUnicodeErrorObject:

sub: proc ofPyUnicodeErrorObject(obj`gensym123: PyObject): bool

ofPyUnicodeTranslateErrorObject:

sub: proc ofPyUnicodeTranslateErrorObject(obj`gensym152: PyObject): bool

ofPyUnicodeWarningObject:

warningobject: proc ofPyUnicodeWarningObject(obj`gensym46: PyObject): bool

ofPyUserWarningObject:

warningobject: proc ofPyUserWarningObject(obj`gensym88: PyObject): bool

ofPyValueErrorObject:

base: proc ofPyValueErrorObject(obj`gensym83: PyObject): bool

ofPyWarningMessageObject:

warningobject: proc ofPyWarningMessageObject(obj`gensym5: PyObject): bool

ofPyWarningObject:

warningobject: proc ofPyWarningObject(obj`gensym0: PyObject): bool

ofPyZeroDivisionErrorObject:

sub: proc ofPyZeroDivisionErrorObject(obj`gensym15: PyObject): bool

ofPyZipObject:

iterobjects: proc ofPyZipObject(obj`gensym0: PyObject): bool

OpArg:

codeobject: type OpArg

OpCode:

opcode: enum OpCode

ord:

unarys: proc ord(c: PyObject): PyObject

orPrintTb:

orPyBoolObjectMagic:

boolobjectImpl: proc orPyBoolObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

orPyDictObjectMagic:

dictobject: proc orPyDictObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

orPyFrozenSetObjectMagic:

setobject: proc orPyFrozenSetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

orPyInstanceObjectMagic:

classobject: proc orPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

orPyIntObjectMagic:

intobjectImpl: proc orPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

orPySetObjectMagic:

setobject: proc orPySetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

pairs:

parse:

parser: proc parse(input: string; fileName: string; mode = Mode.File): ParseNode

ParseErrorcode:

apis: enum ParseErrorcode

parseInt:

ops: proc parseInt[C: char | Rune](s: openArray[C]; res: var PyIntObject): int

parseModeEnum:

lexerTypes: proc parseModeEnum(s: string; res: var Mode): bool

parseName:

lexer_utils: template parseName(s: string; res: var string; idx: var int; msg: var string): bool

ParseNode:

parser: type ParseNode

parseNumber:

lexer_utils: proc parseNumber(s: string; res: var string; idx: var int; msg: var string): bool

parseWithState:

parser: proc parseWithState(input: string; lexer: Lexer; mode = Mode.File; parseNodeArg: ParseNode = nil): ParseNode

partition:

pkgs: proc partition(self: PyStrObject; sep: PyStrObject): PyTupleObject

partitionPybytearrayObjectMethod:

byteobjectsImpl: proc partitionPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

partitionPybytesObjectMethod:

byteobjectsImpl: proc partitionPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

partitionPyStrObjectMethod:

meth: proc partitionPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

Patch:

versionInfo: const Patch

PLATFORM:

getplatform: const PLATFORM

pop:

popitemPyDictObjectMethod:

dictobjectImpl: proc popitemPyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

popMode:

lexerTypes: proc popMode(lexer: Lexer): tokenizer_mode

popPybytearrayObjectMethod:

byteobjectsImpl: proc popPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

popPyDictObjectMethod:

dictobject: proc popPyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

popPyListObjectMethod:

listobject: proc popPyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

popPySetObjectMethod:

setobject: proc popPySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

positive:

signbit: template positive(self: PyIntObject): untyped

positivePyComplexObjectMagic:

complexobjectImpl: proc positivePyComplexObjectMagic(selfNoCast: PyObject): PyObject

positivePyFloatObjectMagic:

floatobject: proc positivePyFloatObjectMagic(selfNoCast: PyObject): PyObject

positivePyInstanceObjectMagic:

classobject: proc positivePyInstanceObjectMagic(selfNoCast: PyObject): PyObject

positivePyIntObjectMagic:

intobjectImpl: proc positivePyIntObjectMagic(selfNoCast: PyObject): PyObject

pow:

pow3rdArgMustBeNone:

pyobject: template pow3rdArgMustBeNone()

powNeg:

ops: proc powNeg(a, b: PyIntObject): PyObject

powPos:

ops: proc powPos(a, b: PyIntObject): PyIntObject

powPyComplexObjectMagic:

complexobjectImpl: proc powPyComplexObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

powPyFloatObjectMagic:

floatobject: proc powPyFloatObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

powPyInstanceObjectMagic:

classobject: proc powPyInstanceObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

powPyIntObjectMagic:

intobjectImpl: proc powPyIntObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

pragmaRaiseNode:

asdl: proc pragmaRaiseNode(p: NimNode = nil; raises: varargs[NimNode]): NimNode

pragmaRaiseSyntaxErrorNode:

asdl: proc pragmaRaiseSyntaxErrorNode(p: NimNode = nil): NimNode

prepareIntFlagOr:

intflags: template prepareIntFlagOr()

print_expr:

intrinsics: proc print_expr(value: PyObject; res: var PyObject): PyBaseErrorObject

priRetIfExc:

privateGetframeNoAudit:

neval_frame: proc privateGetframeNoAudit(depth: int): PyObject

privateGetTracebackRef:

base: proc privateGetTracebackRef(exc: PyBaseExceptionObject): PyObject

privateGetTracebackRef=:

base: proc privateGetTracebackRef=(exc: PyBaseExceptionObject; val: PyObject)

privateOwner:

frameobject: proc privateOwner(f: PyFrameObject): var PyInterpFrameOwner

privatePyErr_DisplayException:

pyerr_display: proc privatePyErr_DisplayException(file: PyObject; value: PyBaseExceptionObject)

privatePyNumber_Index:

numobjects_comm_with_warn: proc privatePyNumber_Index(item: PyObject): PyObject

pushedCStackRef:

attrsGeneric: proc pushedCStackRef(): PyCStackRef

pyAllowThreads:

ceval: template pyAllowThreads(body)

PyArg_NoKw:

PyArg_ParseTuple:

vargs: macro PyArg_ParseTuple(name: string; args: openArray[PyObject]; min, max: static Natural; vargs: varargs[typed])

PyArg_ParseTupleAndKeywords:

va_and_kw: macro PyArg_ParseTupleAndKeywords(funcname: string; args: openArray[PyObject]; keywords: PyDictObject; kwOnlyList: static openArray[string]; vargs: varargs[typed]): PyBaseErrorObject

PyArg_ParseTupleAndKeywordsAs:

va_and_kw: macro PyArg_ParseTupleAndKeywordsAs(funcname: string; args: openArray[PyObject]; keywords: PyDictObject; kwOnlyList: static openArray[string]; vargs: varargs[untyped]): PyBaseErrorObject

PyArg_UnpackKeywords:

PyArg_UnpackKeywordsAs:

kwargs: macro PyArg_UnpackKeywordsAs(fname: string; kwargs: PyDictObject; keywords: static openArray[string]; vars: varargs[untyped]): PyBaseErrorObject

PyArg_UnpackKeywordsTo:

PyArg_UnpackKeywordsToAs:

kwargs: macro PyArg_UnpackKeywordsToAs(fname: string; kwargs: PyDictObject; vars: varargs[untyped]): PyBaseErrorObject

PyArg_UnpackTuple:

PyArg_ValidateKeywordArguments:

PyArg_VaParseTuple:

vargs: proc PyArg_VaParseTuple(name: NimNode; args: NimNode; min, max: Natural; vargs: NimNode): NimNode

PyArg_VaParseTupleAndKeywords:

va_and_kw: proc PyArg_VaParseTupleAndKeywords(funcname: NimNode; args: NimNode; keywords: NimNode; kwOnlyList: openArray[string]; vargs: NimNode): NimNode

PyArg_VaParseTupleAndKeywordsAs:

va_and_kw: proc PyArg_VaParseTupleAndKeywordsAs(funcname: NimNode; args: NimNode; keywords: NimNode; kwOnlyList: openArray[string]; vargs: NimNode): NimNode

PyArg_VaUnpackKeywords:

PyArithmeticErrorObject:

base: type PyArithmeticErrorObject

pyArithmeticErrorObjectType:

base: let pyArithmeticErrorObjectType

PyAssertionErrorObject:

base: type PyAssertionErrorObject

pyAssertionErrorObjectType:

base: let pyAssertionErrorObjectType

Py_atomic_compare_exchange:

pyatomic: proc Py_atomic_compare_exchange[T: AtomType](obj, expected: ptr T; desired: T): bool

Py_atomic_load:

pyatomic: template Py_atomic_load[T: AtomType | SomeFloat | ref](obj: ptr T): T

Py_atomic_loadRELAXED:

Py_atomic_loadSEQ_CST:

Py_atomic_store:

pyatomic: template Py_atomic_store[T: AtomType | SomeFloat | ref](obj: ptr T; value: T)

Py_atomic_storeRELAXED:

Py_atomic_storeSEQ_CST:

PyAttributeErrorObject:

base: type PyAttributeErrorObject

pyAttributeErrorObjectType:

base: let pyAttributeErrorObjectType

Py_AuditHookFunction:

audit: type Py_AuditHookFunction

PyBaseErrorObject:

base: type PyBaseErrorObject

pyBaseErrorObjectType:

base: let pyBaseErrorObjectType

PyBaseExceptionGroupObject:

base: type PyBaseExceptionGroupObject

pyBaseExceptionGroupObjectType:

base: let pyBaseExceptionGroupObjectType

PyBaseExceptionObject:

base: type PyBaseExceptionObject

pyBaseExceptionObjectType:

base: let pyBaseExceptionObjectType

PyBlockingIOErrorObject:

sub: type PyBlockingIOErrorObject

pyBlockingIOErrorObjectType:

sub: let pyBlockingIOErrorObjectType

PyBoolObject:

boolobject: type PyBoolObject

pyBoolObjectType:

boolobject: let pyBoolObjectType

PyBoundMethodObject:

funcobject: type PyBoundMethodObject

pyBoundMethodObjectType:

funcobject: let pyBoundMethodObjectType

PyBrokenPipeErrorObject:

sub: type PyBrokenPipeErrorObject

pyBrokenPipeErrorObjectType:

sub: let pyBrokenPipeErrorObjectType

PyBufferErrorObject:

base: type PyBufferErrorObject

pyBufferErrorObjectType:

base: let pyBufferErrorObjectType

Py_BUILD_CORE:

defines: const Py_BUILD_CORE

Py_BUILD_CORE_MODULE:

defines: const Py_BUILD_CORE_MODULE

Py_BuildValue:

modsupport: macro Py_BuildValue(args: varargs[typed]): PyObject

PyBuiltin_Init:

bltinmodule_mod: proc PyBuiltin_Init(config: PyConfig): PyObject

PyBuiltinsModuleObject:

bltinmodule_mod: type PyBuiltinsModuleObject

pyBuiltinsModuleObjectType:

bltinmodule_mod: let pyBuiltinsModuleObjectType

PyByteArray_FromObject:

byteobjects: proc PyByteArray_FromObject(x: PyObject): PyObject

PyByteArrayObject:

byteobjects: type PyByteArrayObject

pyByteArrayObjectType:

byteobjects: let pyByteArrayObjectType

PyBytes_FromObject:

byteobjects: proc PyBytes_FromObject(x: PyObject): PyObject

PyBytesObject:

byteobjects: type PyBytesObject

pyBytesObjectType:

byteobjects: let pyBytesObjectType

PyBytesWarningObject:

warningobject: type PyBytesWarningObject

pyBytesWarningObjectType:

warningobject: let pyBytesWarningObjectType

PyBytesWriter:

byteobjects: object PyBytesWriter

PyCellObject:

cellobject: type PyCellObject

pyCellObjectType:

cellobject: let pyCellObjectType

PyCF:

compile: enum PyCF

PyCF_MASK:

compile: const PyCF_MASK

pyCFuncPragma:

pyobjectBase: macro pyCFuncPragma(def): untyped

Py_CheckMainModule:

pystate: proc Py_CheckMainModule(module: PyObject): PyBaseErrorObject

Py_CheckSlotResult:

PyChildProcessErrorObject:

sub: type PyChildProcessErrorObject

pyChildProcessErrorObjectType:

sub: let pyChildProcessErrorObjectType

PyClassMethodDescrObject:

descrobject: type PyClassMethodDescrObject

pyClassMethodDescrObjectType:

descrobject: let pyClassMethodDescrObjectType

PyCodeAddressRange:

locApis: object PyCodeAddressRange

PyCodeFutureOption:

compile: enum PyCodeFutureOption

PyCodeObject:

codeobject: type PyCodeObject

pyCodeObjectType:

codeobject: let pyCodeObjectType

PyCommonMethodDescrObject:

descrobject: type PyCommonMethodDescrObject

pyCommonMethodDescrObjectType:

descrobject: let pyCommonMethodDescrObjectType

PyCompareOp:

compare: enum PyCompareOp

PyCompilerFlags:

compile: type PyCompilerFlags

Py_CompileStringObject:

compile: proc Py_CompileStringObject(str: string; filename: PyStrObject; mode: Mode; flags = initPyCompilerFlags(); optimize = -1): PyObject

PyComplexObject:

decl: type PyComplexObject

pyComplexObjectType:

decl: let pyComplexObjectType

PyConfig:

coreconfig: object PyConfig

pyConfig:

coreconfig: var pyConfig

PyConfig_INIT_COMPAT:

pycore_initconfig: PyConfigInitEnum.PyConfig_INIT_COMPAT

PyConfigInitEnum:

pycore_initconfig: enum PyConfigInitEnum

PyConfig_INIT_ISOLATED:

pycore_initconfig: PyConfigInitEnum.PyConfig_INIT_ISOLATED

PyConfig_INIT_PYTHON:

pycore_initconfig: PyConfigInitEnum.PyConfig_INIT_PYTHON

PyConnectErrorObject:

sub: type PyConnectErrorObject

pyConnectErrorObjectType:

sub: let pyConnectErrorObjectType

PyConnectionAbortedErrorObject:

sub: type PyConnectionAbortedErrorObject

pyConnectionAbortedErrorObjectType:

sub: let pyConnectionAbortedErrorObjectType

PyConnectionErrorObject:

sub: type PyConnectionErrorObject

pyConnectionErrorObjectType:

sub: let pyConnectionErrorObjectType

PyConnectionRefusedErrorObject:

sub: type PyConnectionRefusedErrorObject

pyConnectionRefusedErrorObjectType:

sub: let pyConnectionRefusedErrorObjectType

PyConnectionResetErrorObject:

sub: type PyConnectionResetErrorObject

pyConnectionResetErrorObjectType:

sub: let pyConnectionResetErrorObjectType

Py_convert_int_to_double:

utils: proc Py_convert_int_to_double(v: var PyObject; dbl: var float): bool

pycore_init_builtins:

builtins: proc pycore_init_builtins(): PyBaseErrorObject

PyCStackRef:

attrsGeneric: object PyCStackRef

Py_DEBUG:

defines: const Py_DEBUG

Py_DECLARE_STR:

pycore_global_strings: template Py_DECLARE_STR(name; str: static string)

PyDeprecationWarningObject:

warningobject: type PyDeprecationWarningObject

pyDeprecationWarningObjectType:

warningobject: let pyDeprecationWarningObjectType

pyDestructorPragma:

pyobjectBase: template pyDestructorPragma(def): untyped

PyDict_FromKeys:

dictobjectImpl: proc PyDict_FromKeys(cls: PyObject; iterable, value: PyObject): PyObject

PyDictObject:

decl: type PyDictObject

pyDictObjectType:

decl: let pyDictObjectType

PyDictProxyObject:

dictproxyobject: type PyDictProxyObject

pyDictProxyObjectType:

dictproxyobject: let pyDictProxyObjectType

Py_DisplaySourceLine:

PyDoc_STRVAR:

pymacro: template PyDoc_STRVAR(name; str)

pyDUId:

pycore_global_strings: template pyDUId(id: untyped{~nkRStrLit}): PyStrObject

pyEllipsis:

sliceobject: let pyEllipsis

PyEllipsisObject:

sliceobject: type PyEllipsisObject

pyEllipsisObjectType:

sliceobject: let pyEllipsisObjectType

PyEncodingWarningObject:

warningobject: type PyEncodingWarningObject

pyEncodingWarningObjectType:

warningobject: let pyEncodingWarningObjectType

PyEnumerateObject:

enumobject: type PyEnumerateObject

pyEnumerateObjectType:

enumobject: let pyEnumerateObjectType

PyEOFErrorObject:

base: type PyEOFErrorObject

pyEOFErrorObjectType:

base: let pyEOFErrorObjectType

Py_EQ:

compare: PyCompareOp.Py_EQ

PyErr_BadArgument:

errors: proc PyErr_BadArgument(): PyTypeErrorObject

PyErr_BadInternalCall:

PyErr_CreateException:

extra_utils: proc PyErr_CreateException(exception_type: PyTypeObject; value: PyObject): PyBaseExceptionObject

PyErr_Display:

pyerr_display: proc PyErr_Display(unused: PyObject; value: PyBaseExceptionObject; tb: PyObject)

PyErr_DisplayException:

pyerr_display: proc PyErr_DisplayException(value: PyBaseExceptionObject)

PyErr_Format:

baseapi: proc PyErr_Format[E: PyBaseErrorObject](exc: E; msg: PyStrObject)

PyErr_FormatUnraisable:

errors: proc PyErr_FormatUnraisable(msg: PyStrObject)

PyErr_Print:

pyerr: template PyErr_Print(exc: PyBaseErrorObject)

PyErr_PrintEx:

pyerr: proc PyErr_PrintEx(exc: PyBaseErrorObject; set_sys_last_vars: bool = false)

PyEval_ConversionFuncs:

ceval: const PyEval_ConversionFuncs

PyEval_EnsureBuiltins:

globalslocals: proc PyEval_EnsureBuiltins(globals: PyObject): PyBaseErrorObject

PyEval_GetBuiltins:

builtindict: proc PyEval_GetBuiltins(): PyDictObject

PyEval_GetFrame:

neval_frame: proc PyEval_GetFrame(): PyFrameObject

PyEval_GetFrameLocals:

globalslocals: proc PyEval_GetFrameLocals(): PyObject

PyEval_GetGlobals:

neval_frame: proc PyEval_GetGlobals(): PyObject

PyEval_GetGlobalsFromRunningMain:

globalslocals: proc PyEval_GetGlobalsFromRunningMain(): PyObject

PyEval_MergeCompilerFlags:

neval: proc PyEval_MergeCompilerFlags(cf: PyCompilerFlags): bool

PyEval_SpecialMethodCanSuggest:

ceval: proc PyEval_SpecialMethodCanSuggest(self: PyObject; oparg: int): bool

PyExceptionObject:

base: type PyExceptionObject

pyExceptionObjectType:

base: let pyExceptionObjectType

PyExc_InitTypes:

exceptionsImpl: proc PyExc_InitTypes(): PyBaseErrorObject

PyExecutor:

npython: object PyExecutor

Py_Exit:

exit: proc Py_Exit(sts: int)

pyFalseObj:

boolobject: let pyFalseObj

Py_FatalError:

pyerrors: template Py_FatalError(message)

Py_FatalErrorFunc:

Py_FdIsInteractive:

utils: proc Py_FdIsInteractive(fp: fileio.File; filename: PyStrObject): bool

PyFileExistsErrorObject:

sub: type PyFileExistsErrorObject

pyFileExistsErrorObjectType:

sub: let pyFileExistsErrorObjectType

PyFileNotFoundErrorObject:

sub: type PyFileNotFoundErrorObject

pyFileNotFoundErrorObjectType:

sub: let pyFileNotFoundErrorObjectType

PyFile_WritelineString:

PyFilterObject:

iterobjects: type PyFilterObject

pyFilterObjectType:

iterobjects: let pyFilterObjectType

PyFloat_AsDouble:

toval: proc PyFloat_AsDouble(op: PyObject; v: var float): PyBaseErrorObject

PyFloat_AsFloat:

toval: proc PyFloat_AsFloat(op: PyObject; v: var float32): PyBaseErrorObject

PyFloat_FromString:

PyFloatingPointErrorObject:

sub: type PyFloatingPointErrorObject

pyFloatingPointErrorObjectType:

sub: let pyFloatingPointErrorObjectType

PyFloatObject:

decl: type PyFloatObject

pyFloatObjectType:

decl: let pyFloatObjectType

pyForIn:

iterobject: template pyForIn(it; iterableToLoop: PyObject; doWithIt)

PyFormatValueCode:

ceval: enum PyFormatValueCode

PyFrameLocalsProxyObject:

frameobject: type PyFrameLocalsProxyObject

pyFrameLocalsProxyObjectType:

frameobject: let pyFrameLocalsProxyObjectType

PyFrameObject:

frameobject: type PyFrameObject

pyFrameObjectType:

frameobject: let pyFrameObjectType

PyFrozenSetObject:

setobject: type PyFrozenSetObject

pyFrozenSetObjectType:

setobject: let pyFrozenSetObjectType

PyFunctionObject:

funcobject: type PyFunctionObject

pyFunctionObjectType:

funcobject: let pyFunctionObjectType

PyFutureWarningObject:

warningobject: type PyFutureWarningObject

pyFutureWarningObjectType:

warningobject: let pyFutureWarningObjectType

Py_GE:

compare: PyCompareOp.Py_GE

PyGeneratorExitObject:

base: type PyGeneratorExitObject

pyGeneratorExitObjectType:

base: let pyGeneratorExitObjectType

Py_GetBuildInfo:

getbuildinfo: proc Py_GetBuildInfo(): string

Py_GetCompiler:

getversion: proc Py_GetCompiler(): string

Py_GetConfig:

coreconfig: proc Py_GetConfig(): PyConfig

Py_GetCopyright:

getcopyright: proc Py_GetCopyright(): string

Py_GetMainModule:

pystate: proc Py_GetMainModule(): PyObject

PyGetSetDescrObject:

descrobject: type PyGetSetDescrObject

pyGetSetDescrObjectType:

descrobject: let pyGetSetDescrObjectType

Py_GetVersion:

getversion: proc Py_GetVersion(): string

Py_GIL_DISABLED:

defines: const Py_GIL_DISABLED

Py_GT:

compare: PyCompareOp.Py_GT

Py_HandleSystemExitAndKeyboardInterrupt:

pyerr_sysexit_keyinter: proc Py_HandleSystemExitAndKeyboardInterrupt(exc: PyBaseErrorObject; exitcode: var int): bool

Py_HashBuffer:

Py_HashDouble:

hashes: proc Py_HashDouble(self: PyObject; v: float): Hash

PyHash_FuncDef:

hash_def: object PyHash_FuncDef

PyHash_GetFuncDef:

hash_def: proc PyHash_GetFuncDef(): PyHash_FuncDef

Py_HashPointer:

hash: proc Py_HashPointer(p: pointer | int): Hash

PyHash_SetFuncDef:

hash_def: proc PyHash_SetFuncDef(x: PyHash_FuncDef)

pyId:

pyImport:

main: proc pyImport(rt: Evaluator; name: PyStrObject): PyObject

PyImport_AddModuleRef:

PyImportErrorObject:

base: type PyImportErrorObject

pyImportErrorObjectType:

base: let pyImportErrorObjectType

PyImport_GetModule:

utils: proc PyImport_GetModule(name: PyStrObject; res: var PyObject): PyBaseErrorObject

PyImportTimePerf:

coreconfig: enum PyImportTimePerf

PyImportWarningObject:

warningobject: type PyImportWarningObject

pyImportWarningObjectType:

warningobject: let pyImportWarningObjectType

PyIndentationErrorObject:

sub: type PyIndentationErrorObject

pyIndentationErrorObjectType:

sub: let pyIndentationErrorObjectType

PyIndexErrorObject:

sub: type PyIndexErrorObject

pyIndexErrorObjectType:

sub: let pyIndexErrorObjectType

pyInit:

lifecycle: proc pyInit(args: seq[string])

Py_Initialize:

lifecycle: proc Py_Initialize()

Py_InitializeFromConfig:

lifecycle: proc Py_InitializeFromConfig(config: PyConfig)

PyInstanceObject:

classobject: type PyInstanceObject

pyInstanceObjectType:

classobject: let pyInstanceObjectType

PyInteractiveSrcObject:

apis: type PyInteractiveSrcObject

pyInteractiveSrcObjectType:

apis: let pyInteractiveSrcObjectType

PyInterpFrameOwner:

pycore_interpframe_struct: enum PyInterpFrameOwner

PyInterpolationObject:

interpolationobject: type PyInterpolationObject

pyInterpolationObjectType:

interpolationobject: let pyInterpolationObjectType

PyInterpreterState_GET_long_state:

pycore_int: template PyInterpreterState_GET_long_state(): untyped

PyInterruptedErrorObject:

sub: type PyInterruptedErrorObject

pyInterruptedErrorObjectType:

sub: let pyInterruptedErrorObjectType

Py_Int_Float_InitTypes:

initInfo: template Py_Int_Float_InitTypes(fatalCb)

PyIntObject:

decl: type PyIntObject

pyIntObjectType:

decl: let pyIntObjectType

pyIntOne:

numobjects_comm: let pyIntOne

PyInt_OverflowCType:

ops_toint: proc PyInt_OverflowCType(ctypeName: string): PyOverflowErrorObject

pyIntTen:

numobjects_comm: let pyIntTen

pyIntTwo:

numobjects_comm: let pyIntTwo

pyIntZero:

numobjects_comm: let pyIntZero

PyIOErrorObject:

sub: type PyIOErrorObject

pyIOErrorObjectType:

sub: let pyIOErrorObjectType

Py_IS:

pyobjectBase: proc Py_IS(a, b: PyObject): bool

PyIsADirectoryErrorObject:

sub: type PyIsADirectoryErrorObject

pyIsADirectoryErrorObjectType:

sub: let pyIsADirectoryErrorObjectType

Py_IS_TYPE:

pyobjectBase: proc Py_IS_TYPE(a: PyObject; b: PyTypeObject): bool

PyIter_Check:

iter: proc PyIter_Check(obj: PyObject): bool

PyIter_Next:

iter: proc PyIter_Next(iter: PyObject): PyObject

PyIter_NextItem:

iter: proc PyIter_NextItem(iter: PyObject; item: var PyObject): GetItemRes

PyKeyboardInterruptObject:

base: type PyKeyboardInterruptObject

pyKeyboardInterruptObjectType:

base: let pyKeyboardInterruptObjectType

PyKeyErrorObject:

sub: type PyKeyErrorObject

pyKeyErrorObjectType:

sub: let pyKeyErrorObjectType

PyKwArgType:

pyobjectBase: type PyKwArgType

Py_LE:

compare: PyCompareOp.Py_LE

PyListObject:

listobject: type PyListObject

pyListObjectType:

listobject: let pyListObjectType

PyLockErrorObject:

base: type PyLockErrorObject

pyLockErrorObjectType:

base: let pyLockErrorObjectType

PyLong_AsLongAndOverflow:

number: proc PyLong_AsLongAndOverflow(vv: PyObject; overflow: var IntSign; res: var int): PyBaseErrorObject

PyLong_AsSize_t:

PyLong_AsSsize_t:

PyLong_FromBytes:

fromx: proc PyLong_FromBytes(buffer: openArray[char]; base = 10): PyObject

PyLong_FromString:

ops: proc PyLong_FromString[C: char](s: openArray[C]; nParsed: var int; base: int = 10): PyObject

PyLong_FromUnicodeObject:

fromx: proc PyLong_FromUnicodeObject(u: PyStrObject; base = 10): PyObject

PyLookupErrorObject:

base: type PyLookupErrorObject

pyLookupErrorObjectType:

base: let pyLookupErrorObjectType

Py_LT:

compare: PyCompareOp.Py_LT

PyMajor:

versionInfo: const PyMajor

PyMapObject:

iterobjects: type PyMapObject

pyMapObjectType:

iterobjects: let pyMapObjectType

PyMapping_GetOptionalItem:

mapping: proc PyMapping_GetOptionalItem(obj: PyObject; key: PyObject; res: var PyObject): PyBaseErrorObject

PyMemberDef:

descrobject: object PyMemberDef

PyMemberDefFlags:

descrobject: object PyMemberDefFlags

pyMemberDefFlagsFromTags:

descrobject: macro pyMemberDefFlagsFromTags(tags: varargs[untyped]): PyMemberDefFlags

PyMemberDescrObject:

descrobject: type PyMemberDescrObject

pyMemberDescrObjectType:

descrobject: let pyMemberDescrObjectType

PyMember_GetOne:

structmember: proc PyMember_GetOne(obj_addr: PyObject; l: PyMemberDef): PyObject

PyMember_SetOne:

structmember: proc PyMember_SetOne(obj_addr: PyObject; l: PyMemberDef; v: PyObject): PyBaseErrorObject

PyMemoryErrorObject:

base: type PyMemoryErrorObject

pyMemoryErrorObjectType:

base: let pyMemoryErrorObjectType

PyMethodDescrObject:

descrobject: type PyMethodDescrObject

pyMethodDescrObjectType:

descrobject: let pyMethodDescrObjectType

PyMinor:

versionInfo: const PyMinor

Py_mod_create:

moduledefs: PyModuleDef_SlotKind.Py_mod_create

Py_mod_exec:

moduledefs: PyModuleDef_SlotKind.Py_mod_exec

PyModule_CreateInitialized:

moduleobjectImpl: template PyModule_CreateInitialized(nameId: untyped; module_api_version = NPYTHON_API_VERSION): PyObject

PyModuleDef:

moduledefs: type PyModuleDef

PyModuleDef_Slot:

moduledefs: object PyModuleDef_Slot

PyModuleDef_SlotKind:

moduledefs: enum PyModuleDef_SlotKind

PyModuleDef_Slots:

moduledefs: type PyModuleDef_Slots

PyModuleNotFoundErrorObject:

sub: type PyModuleNotFoundErrorObject

pyModuleNotFoundErrorObjectType:

sub: let pyModuleNotFoundErrorObjectType

PyModuleObject:

moduleobject: type PyModuleObject

pyModuleObjectType:

moduleobject: let pyModuleObjectType

PyModuleSpec_IsInitializing:

utils: proc PyModuleSpec_IsInitializing(spec: PyObject; res: var bool): PyBaseErrorObject

Py_mod_unknown:

moduledefs: PyModuleDef_SlotKind.Py_mod_unknown

PyNameErrorObject:

base: type PyNameErrorObject

pyNameErrorObjectType:

base: let pyNameErrorObjectType

PyNamespaceObject:

namespaceobject: type PyNamespaceObject

pyNamespaceObjectType:

namespaceobject: let pyNamespaceObjectType

Py_NE:

compare: PyCompareOp.Py_NE

PyNimFuncObject:

methodobject: type PyNimFuncObject

pyNimFuncObjectType:

methodobject: let pyNimFuncObjectType

PyNimIteratorIterObject:

iterobject: type PyNimIteratorIterObject

pyNimIteratorIterObjectType:

iterobject: let pyNimIteratorIterObjectType

PyNimSeqIterObject:

iterobject: type PyNimSeqIterObject

pyNimSeqIterObjectType:

iterobject: let pyNimSeqIterObjectType

PyNimSequence_Check:

sequence: template PyNimSequence_Check(o: PyObject): bool

pyNone:

noneobject: let pyNone

PyNoneObject:

noneobject: type PyNoneObject

pyNoneObjectType:

noneobject: let pyNoneObjectType

PyNotADirectoryErrorObject:

sub: type PyNotADirectoryErrorObject

pyNotADirectoryErrorObjectType:

sub: let pyNotADirectoryErrorObjectType

pyNotImplemented:

pyobject: let pyNotImplemented

PyNotImplementedErrorObject:

sub: type PyNotImplementedErrorObject

pyNotImplementedErrorObjectType:

sub: let pyNotImplementedErrorObjectType

PyNotImplementedObject:

pyobject: type PyNotImplementedObject

pyNotImplementedObjectType:

pyobject: let pyNotImplementedObjectType

PyNumberAbsolute:

number: proc PyNumberAbsolute(v: PyObject): PyObject

PyNumberadd:

number: proc PyNumberadd(v, w: PyObject): PyObject

PyNumberAnd:

number: proc PyNumberAnd(v, w: PyObject): PyObject

PyNumber_AsCharOr:

byteobjects: template PyNumber_AsCharOr(vv: PyObject; errSubject = "byte"; orDoIt): char

PyNumber_AsCharOrRet:

byteobjects: template PyNumber_AsCharOrRet(vv: PyObject; errSubject = "byte"): char

PyNumber_AsClampedSsize_t:

ops_imp_warn: proc PyNumber_AsClampedSsize_t(pyObj: PyObject; res: var int): PyTypeErrorObject

PyNumber_AsSsize_t:

PyNumberdivmod:

number: proc PyNumberdivmod(v, w: PyObject): PyObject

PyNumberFloat:

fromx: proc PyNumberFloat(v: PyObject): PyObject

PyNumber_Float:

fromx: proc PyNumber_Float(o: PyObject; resf: var PyFloatObject): PyBaseErrorObject

PyNumber_FloatOrIntImpl:

helpers: template PyNumber_FloatOrIntImpl(o: PyObject; resObj: typed; nameId; doWithIndexRes)

PyNumberfloorDiv:

number: proc PyNumberfloorDiv(v, w: PyObject): PyObject

PyNumber_Index:

PyNumberInvert:

number: proc PyNumberInvert(v: PyObject): PyObject

PyNumberLong:

fromx: proc PyNumberLong(v: PyObject): PyObject

PyNumber_Long:

fromx: proc PyNumber_Long(o: PyObject; resi: var PyIntObject): PyBaseErrorObject

PyNumberlshift:

number: proc PyNumberlshift(v, w: PyObject): PyObject

PyNumberMod:

number: proc PyNumberMod(v, w: PyObject): PyObject

PyNumbermul:

number: proc PyNumbermul(v, w: PyObject): PyObject

PyNumberNegative:

number: proc PyNumberNegative(v: PyObject): PyObject

PyNumberOr:

number: proc PyNumberOr(v, w: PyObject): PyObject

PyNumberPositive:

number: proc PyNumberPositive(v: PyObject): PyObject

PyNumber_Power:

number: proc PyNumber_Power(v, w, z: PyObject): PyObject

PyNumber_PowerNoMod:

number: proc PyNumber_PowerNoMod(lhs, rhs: PyObject): PyObject

PyNumberrshift:

number: proc PyNumberrshift(v, w: PyObject): PyObject

PyNumbersub:

number: proc PyNumbersub(v, w: PyObject): PyObject

PyNumber_ToBase:

number: proc PyNumber_ToBase(n: PyObject; base: uint8): PyObject

PyNumbertruediv:

number: proc PyNumbertruediv(v, w: PyObject): PyObject

PyNumberXor:

number: proc PyNumberXor(v, w: PyObject): PyObject

PyNumber_Xxx_Wrap:

numobjects_comm_with_warn: template PyNumber_Xxx_Wrap[Py: PyObject](o: PyObject; magicPureId, typeId; prePureFuncName: string; resTypeNameMaxLen: int; resObj: var Py)

PyObject:

pyobjectBase: type PyObject

PyObject_ASCII:

strings: proc PyObject_ASCII(obj: PyObject): PyObject

PyObject_ASCIINonNil:

strings: proc PyObject_ASCIINonNil(us: PyObject): PyObject

PyObject_DelAttr:

attrs: proc PyObject_DelAttr(self: PyObject; name: PyStrObject | PyObject): PyObject

PyObject_Eq:

hash: proc PyObject_Eq(obj1, obj2: PyObject; exc: var PyBaseErrorObject): bool

PyObject_Format:

format: proc PyObject_Format(obj: PyObject; format_spec: PyObject): PyObject

PyObject_GenericDelAttr:

attrsGeneric: proc PyObject_GenericDelAttr(self: PyObject; nameObj: PyObject): PyObject

PyObject_GenericGetAttr:

attrsGeneric: proc PyObject_GenericGetAttr(self: PyObject; name: PyObject): PyObject

PyObject_GenericGetAttrWithDict:

PyObject_GenericSetAttr:

attrsGeneric: proc PyObject_GenericSetAttr(self: PyObject; nameObj: PyObject; value: PyObject): PyObject

PyObject_GetAttr:

attrs: proc PyObject_GetAttr(v: PyObject; name: PyStrObject | PyObject): PyObject

PyObject_GetItem:

dunder: proc PyObject_GetItem(o: PyObject; key: PyObject): PyObject

PyObject_GetIter:

iter: template PyObject_GetIter(o: PyObject): PyObject

PyObject_GetOptionalAttr:

attrs: proc PyObject_GetOptionalAttr(v: PyObject; name: PyStrObject | PyObject; res: var PyObject): GetItemRes

PyObject_HasAttrWithError:

attrs: proc PyObject_HasAttrWithError(obj: PyObject; name: PyStrObject | PyObject; exc: var PyBaseErrorObject): GetItemRes

PyObject_Hash:

PyObject_IsTrue:

boolobjectImpl: proc PyObject_IsTrue(v: PyObject; res: var bool): PyBaseErrorObject

PyObject_LookupSpecial:

attrs: proc PyObject_LookupSpecial(self: PyObject; attr: PyStrObject): PyObject

PyObjectObj:

pyobjectBase: object PyObjectObj

PyObject_Println:

io: proc PyObject_Println(op: PyObject; fp: fileio.File; flags: IntFlag[PyPrintFlags] = Py_PRINT_REPR): PyBaseErrorObject

PyObject_Repr:

strings: proc PyObject_Repr(obj: PyObject): PyObject

PyObject_ReprNonNil:

strings: proc PyObject_ReprNonNil(obj: PyObject): PyObject

PyObject_RichCompare:

compare: proc PyObject_RichCompare(v, w: PyObject; op: PyCompareOp; res: var PyObject): PyBaseErrorObject

PyObject_RichCompareBool:

compare: proc PyObject_RichCompareBool(v, w: PyObject; op: PyCompareOp; resb: var bool): PyBaseErrorObject

PyObject_SetAttr:

attrs: proc PyObject_SetAttr(self: PyObject; name: PyStrObject | PyObject; value: PyObject): PyObject

PyObject_SetItem:

dunder: proc PyObject_SetItem(o: PyObject; key, value: PyObject): PyObject

PyObject_Str:

strings: proc PyObject_Str(obj: PyObject): PyObject

PyObject_StrNonNil:

strings: proc PyObject_StrNonNil(obj: PyObject): PyObject

pyObjectType:

pyobjectBase: let pyObjectType

PyObject_TypeCheck:

subtype: proc PyObject_TypeCheck(obj: PyObject; tp: PyTypeObject): bool

PyObjectWithDict:

pyobjectBase: type PyObjectWithDict

PyOSErrorObject:

base: type PyOSErrorObject

pyOSErrorObjectType:

base: let pyOSErrorObjectType

PyOS_FSPath:

utils: proc PyOS_FSPath(path: PyObject): PyObject

PyOverflowErrorObject:

sub: type PyOverflowErrorObject

pyOverflowErrorObjectType:

sub: let pyOverflowErrorObjectType

PyParser_ASTFromFile:

apis: proc PyParser_ASTFromFile(fp: File; filename_obj: PyStrObject; enc: string; mode: Mode; flags: PyCompilerFlags; errcode: var ParseErrorcode; res: var Asdlmodl): PyBaseErrorObject

PyParser_ASTFromString:

apis: proc PyParser_ASTFromString(str: string; filename_obj: PyStrObject; mode: Mode; flags: PyCompilerFlags; res: var Asdlmodl): PyBaseErrorObject

PyParser_InteractiveASTFromFile:

apis: proc PyParser_InteractiveASTFromFile(fp: File; filename_obj: PyStrObject; enc: string; mode: Mode; ps1, ps2: string; flags: PyCompilerFlags; errcode: var ParseErrorcode; interactive_src: var PyInteractiveSrcObject; res: var Asdlmodl): PyBaseErrorObject

PyPatch:

versionInfo: const PyPatch

PyPendingDeprecationWarningObject:

warningobject: type PyPendingDeprecationWarningObject

pyPendingDeprecationWarningObjectType:

warningobject: let pyPendingDeprecationWarningObjectType

PyPermissionErrorObject:

sub: type PyPermissionErrorObject

pyPermissionErrorObjectType:

sub: let pyPermissionErrorObjectType

PyPrintFlags:

io: enum PyPrintFlags

PyProcessLookupErrorObject:

sub: type PyProcessLookupErrorObject

pyProcessLookupErrorObjectType:

sub: let pyProcessLookupErrorObjectType

PyPropertyObject:

descrobject: type PyPropertyObject

pyPropertyObjectType:

descrobject: let pyPropertyObjectType

PyPythonFinalizationErrorObject:

sub: type PyPythonFinalizationErrorObject

pyPythonFinalizationErrorObjectType:

sub: let pyPythonFinalizationErrorObjectType

PyRangeIterObject:

rangeobject: type PyRangeIterObject

pyRangeIterObjectType:

rangeobject: let pyRangeIterObjectType

PyRangeObject:

rangeobject: type PyRangeObject

pyRangeObjectType:

rangeobject: let pyRangeObjectType

PyRecursionErrorObject:

sub: type PyRecursionErrorObject

pyRecursionErrorObjectType:

sub: let pyRecursionErrorObjectType

PyReferenceErrorObject:

base: type PyReferenceErrorObject

pyReferenceErrorObjectType:

base: let pyReferenceErrorObjectType

PyReleaseLevel:

versionInfo: const PyReleaseLevel

PyReleaseLevelStr:

versionInfo: const PyReleaseLevelStr

PY_RELEASE_SERIAL:

versionInfo: const PY_RELEASE_SERIAL

PyResourceWarningObject:

warningobject: type PyResourceWarningObject

pyResourceWarningObjectType:

warningobject: let pyResourceWarningObjectType

PyReversedObject:

enumobject: type PyReversedObject

pyReversedObjectType:

enumobject: let pyReversedObjectType

PyRun_AnyFileExFlags:

pythonrun: proc PyRun_AnyFileExFlags(fp: File; filename: string; closeit = false; flags = initPyCompilerFlags()): bool

PyRun_AnyFileObject:

pythonrun: proc PyRun_AnyFileObject(fp: File; filename: PyStrObject; closeit = false; flags = initPyCompilerFlags()): bool

PyRun_InteractiveLoopObject:

PyRun_InteractiveLoopPre:

utils: proc PyRun_InteractiveLoopPre(): bool

PyRun_SimpleFileObject:

pythonrun: proc PyRun_SimpleFileObject(fp: File; filename: PyStrObject; closeit = false; flags = initPyCompilerFlags()): bool

PyRun_SimpleString:

pythonrun: proc PyRun_SimpleString(str: string): bool

PyRun_SimpleStringFlags:

pythonrun: proc PyRun_SimpleStringFlags(str: string; flags = initPyCompilerFlags()): bool

PyRun_SimpleStringFlagsWithName:

pythonrun: proc PyRun_SimpleStringFlagsWithName(str: string; name: string; flags = initPyCompilerFlags()): bool

PyRun_String:

pythonrun: proc PyRun_String(str: string; mode: Mode; globals: PyDictObject; locals: PyObject): PyObject

PyRun_StringFlags:

pythonrun: proc PyRun_StringFlags(str: string; mode: Mode; globals: PyDictObject; locals: PyObject; flags = initPyCompilerFlags()): PyObject

PyRuntime:

pyruntime_singleton: var PyRuntime

PyRuntimeErrorObject:

base: type PyRuntimeErrorObject

pyRuntimeErrorObjectType:

base: let pyRuntimeErrorObjectType

PyRuntimeWarningObject:

warningobject: type PyRuntimeWarningObject

pyRuntimeWarningObjectType:

warningobject: let pyRuntimeWarningObjectType

PySeqIterObject:

iterobject: type PySeqIterObject

pySeqIterObjectType:

iterobject: let pySeqIterObjectType

PySequence_Check:

sequence: template PySequence_Check(o: PyObject): bool

PySequence_Fast:

list: proc PySequence_Fast(v: PyObject; errMsg: string): PyObject

PySequence_Fast_GET_ITEM:

PySequence_Fast_GET_SIZE:

list: template PySequence_Fast_GET_SIZE(s: PyObject): int

PySequence_FAST_ITEMS:

list: template PySequence_FAST_ITEMS(s: PyObject): openArray[PyObject]

PySequence_GetItem:

sequence: proc PySequence_GetItem(s: PyObject; i: int): PyObject

PySequence_GetItemNonNil:

PySequence_Length:

sequence: template PySequence_Length(s: PyObject; res: var int): PyBaseErrorObject

PySequence_List:

list: proc PySequence_List(v: PyObject): PyObject

PySequence_Size:

sequence: proc PySequence_Size(s: PyObject; res: var int): PyBaseErrorObject

PySequence_Tuple:

tup: proc PySequence_Tuple(v: PyObject): PyObject

Py_SetImmortal:

gc: template Py_SetImmortal(x)

PySetObject:

setobject: type PySetObject

pySetObjectType:

setobject: let pySetObjectType

pysince:

Py_SIZE_ROUND_UP:

pymacro: template Py_SIZE_ROUND_UP(n, a): uint

PySliceObject:

sliceobject: type PySliceObject

pySliceObjectType:

sliceobject: let pySliceObjectType

Py_SourceAsString:

compile: proc Py_SourceAsString(cmd: PyObject; funcname, what: string; cf: PyCompilerFlags; cmd_copy: var PyObject; res: var string): PyBaseErrorObject

PyStackRef:

attrsGeneric: type PyStackRef

PyStackRef_FromPyObjectSteal:

attrsGeneric: proc PyStackRef_FromPyObjectSteal(o: PyObject): PyStackRef

PyStackRef_NULL:

attrsGeneric: const PyStackRef_NULL

PY_STACK_USE_GUIDELINE:

pycore_compile: const PY_STACK_USE_GUIDELINE

PyStaticMethodObject:

funcobject: type PyStaticMethodObject

pyStaticMethodObjectType:

funcobject: let pyStaticMethodObjectType

PyStaticType_InitBuiltin:

typeobject: proc PyStaticType_InitBuiltin(typ: PyTypeObject): PyBaseErrorObject

PyStopAsyncIterationObject:

base: type PyStopAsyncIterationObject

pyStopAsyncIterationObjectType:

base: let pyStopAsyncIterationObjectType

PyStopAsyncIterErrorObject:

base: type PyStopAsyncIterErrorObject

pyStopAsyncIterErrorObjectType:

base: let pyStopAsyncIterErrorObjectType

PyStopIterationObject:

base: type PyStopIterationObject

pyStopIterationObjectType:

base: let pyStopIterationObjectType

PyStopIterErrorObject:

base: type PyStopIterErrorObject

pyStopIterErrorObjectType:

base: let pyStopIterErrorObjectType

Py_STR:

pycore_global_strings: template Py_STR(name): PyStrObject

PyStrFmt:

strformat: type PyStrFmt

Py_string_to_number_with_underscores:

pystrtod: proc Py_string_to_number_with_underscores(s: openArray[char]; what: cstring; obj: PyObject; arg: PyObject; innerfunc: proc ( s: openArray[char]; obj: PyObject): PyObject {.pyCFuncPragma.}): PyObject

PyStrIterObject:

meth: type PyStrIterObject

pyStrIterObjectType:

meth: let pyStrIterObjectType

PyStrObject:

stringobject: type PyStrObject

pyStrObjectType:

stringobject: let pyStrObjectType

PyStructSequence_InitBuiltin:

structseq: template PyStructSequence_InitBuiltin(inter; typ: PyTypeObject; desc: PyStructSequence_Desc): PyBaseErrorObject

PyStructSequence_InitBuiltinWithFlags:

structseq: template PyStructSequence_InitBuiltinWithFlags(_; typ: PyTypeObject; desc: PyStructSequence_Desc; tp_flags: untyped): PyBaseErrorObject

PyStructSequenceObject:

structseq: type PyStructSequenceObject

pyStructSequenceObjectType:

structseq: let pyStructSequenceObjectType

Py_SupHashBuffer:

hash_def: const Py_SupHashBuffer

PySyntaxErrorObject:

base: type PySyntaxErrorObject

pySyntaxErrorObjectType:

base: let pySyntaxErrorObjectType

PySyntaxWarningObject:

warningobject: type PySyntaxWarningObject

pySyntaxWarningObjectType:

warningobject: let pySyntaxWarningObjectType

PySys_Create:

init: proc PySys_Create(sysmod: var PySysModuleObject): PyBaseErrorObject

PySys_EchoStderr:

io: proc PySys_EchoStderr(s: string)

PySys_GetAttr:

PySys_GetIntMaxStrDigits:

int_max_str_digits: proc PySys_GetIntMaxStrDigits(): int

PySys_GetObject:

attrs: proc PySys_GetObject(name: cstring): PyObject

PySys_GetOptionalAttr:

PySysModuleObject:

decl: type PySysModuleObject

pySysModuleObjectType:

decl: let pySysModuleObjectType

PySys_SetAttrNonNil:

attrs: proc PySys_SetAttrNonNil(name: PyStrObject; valueNonNil: PyObject): PyBaseErrorObject

PySys_SetIntMaxStrDigits:

int_max_str_digits: proc PySys_SetIntMaxStrDigits(maxdigits: int): PyBaseErrorObject

PySystemErrorObject:

base: type PySystemErrorObject

pySystemErrorObjectType:

base: let pySystemErrorObjectType

PySystemExitObject:

base: type PySystemExitObject

pySystemExitObjectType:

base: let pySystemExitObjectType

PySys_UpdateConfig:

init: proc PySys_UpdateConfig(sysmod: var PySysModuleObject; config: PyConfig): PyBaseErrorObject

PyTabErrorObject:

sub: type PyTabErrorObject

pyTabErrorObjectType:

sub: let pyTabErrorObjectType

PYTHON_ABI_STRING:

modsupport: const PYTHON_ABI_STRING

PYTHON_ABI_VERSION:

modsupport: const PYTHON_ABI_VERSION

PyThreadState_PushCStackRef:

attrsGeneric: template PyThreadState_PushCStackRef(c)

PyTimeoutErrorObject:

sub: type PyTimeoutErrorObject

pyTimeoutErrorObjectType:

sub: let pyTimeoutErrorObjectType

PY_TPFLAGS:

pyobjectBase: enum PY_TPFLAGS

PyTracebackObject:

exceptionsImpl: type PyTracebackObject

pyTracebackObjectType:

exceptionsImpl: let pyTracebackObjectType

PyTraceBack_Print_Indented_with_noNL_header:

traceback: proc PyTraceBack_Print_Indented_with_noNL_header(v: PyTracebackObject; indent: int; margin: cstring; header_margin: cstring; header: cstring; f: PyObject): PyBaseErrorObject

PyTraceBack_Print_with_noNL_header:

traceback: proc PyTraceBack_Print_with_noNL_header(v: PyTracebackObject; header: cstring; f: PyObject): PyBaseErrorObject

pyTrueObj:

boolobject: let pyTrueObj

PyTuple_Collect:

decl: template PyTuple_Collect(body): PyTupleObject

PyTupleObject:

decl: type PyTupleObject

pyTupleObjectType:

decl: let pyTupleObjectType

PyTuple_Pack:

decl: macro PyTuple_Pack(args: varargs[typed]): PyTupleObject

pyType:

pyobjectBase: template pyType(self: PyObject): PyTypeObject

PyTypeErrorObject:

base: type PyTypeErrorObject

pyTypeErrorObjectType:

base: let pyTypeErrorObjectType

PyType_IsSubtype:

subtype: proc PyType_IsSubtype(a, b: PyTypeObject): bool

PyType_LookupRef:

attrs: proc PyType_LookupRef(typ: PyTypeObject; name: PyStrObject): PyObject

PyType_LookupRefAndVersion:

PyType_LookupStackRefAndVersion:

attrsGeneric: proc PyType_LookupStackRefAndVersion(tp: PyTypeObject; name: PyStrObject; o: var PyObject): uint

PyTypeObject:

pyobjectBase: type PyTypeObject

pyTypeObjectType:

decl: let pyTypeObjectType

PyTypeToken:

pyobjectBase: enum PyTypeToken

PyUnboundLocalErrorObject:

sub: type PyUnboundLocalErrorObject

pyUnboundLocalErrorObjectType:

sub: let pyUnboundLocalErrorObjectType

PyUnicode_AsUTF8AndSize:

utf8apis: proc PyUnicode_AsUTF8AndSize(obj: PyObject; utf8: var string; size: var int): PyBaseErrorObject

PyUnicodeDecodeErrorObject:

sub: type PyUnicodeDecodeErrorObject

pyUnicodeDecodeErrorObjectType:

sub: let pyUnicodeDecodeErrorObjectType

PyUnicode_DecodeFSDefault:

codec: proc PyUnicode_DecodeFSDefault(s: string): PyStrObject

PyUnicodeEncodeErrorObject:

sub: type PyUnicodeEncodeErrorObject

pyUnicodeEncodeErrorObjectType:

sub: let pyUnicodeEncodeErrorObjectType

PyUnicodeErrorObject:

sub: type PyUnicodeErrorObject

pyUnicodeErrorObjectType:

sub: let pyUnicodeErrorObjectType

PyUnicode_FromOrdinal:

PyUnicode_fromStringAndSize:

utf8apis: proc PyUnicode_fromStringAndSize(u: string; size: int): PyObject

PyUnicode_FSDecoder:

codec: proc PyUnicode_FSDecoder(arg: PyObject; val: var PyStrObject): PyBaseErrorObject

PyUnicode_InternMortal:

internal: proc PyUnicode_InternMortal(s: PyStrObject)

PyUnicode_READ:

stringobject: proc PyUnicode_READ(kind: bool; data: UnicodeVariant; index: int): Rune

PyUnicode_TransformDecimalAndSpaceToASCII:

decimalAndSpace: proc PyUnicode_TransformDecimalAndSpaceToASCII(unicode: PyStrObject): PyObject

PyUnicodeTranslateErrorObject:

sub: type PyUnicodeTranslateErrorObject

pyUnicodeTranslateErrorObjectType:

sub: let pyUnicodeTranslateErrorObjectType

PyUnicodeWarningObject:

warningobject: type PyUnicodeWarningObject

pyUnicodeWarningObjectType:

warningobject: let pyUnicodeWarningObjectType

PyUnstable_Object_Dump:

strings: proc PyUnstable_Object_Dump(op: PyObject)

PyUserWarningObject:

warningobject: type PyUserWarningObject

pyUserWarningObjectType:

warningobject: let pyUserWarningObjectType

Py_VaBuildTuple:

modsupport: proc Py_VaBuildTuple(args: NimNode): NimNode

Py_VaBuildValue:

modsupport: proc Py_VaBuildValue(args: NimNode): NimNode

PyValueErrorObject:

base: type PyValueErrorObject

pyValueErrorObjectType:

base: let pyValueErrorObjectType

PY_VERSION_HEX:

getversion: const PY_VERSION_HEX

PyWarningMessageObject:

warningobject: type PyWarningMessageObject

pyWarningMessageObjectType:

warningobject: let pyWarningMessageObjectType

PyWarningObject:

warningobject: type PyWarningObject

pyWarningObjectType:

warningobject: let pyWarningObjectType

Py_WriteIndentedMargin:

traceback: proc Py_WriteIndentedMargin(indent: int; margin: cstring): string

PyZeroDivisionErrorObject:

sub: type PyZeroDivisionErrorObject

pyZeroDivisionErrorObjectType:

sub: let pyZeroDivisionErrorObjectType

PyZipObject:

iterobjects: type PyZipObject

pyZipObjectType:

iterobjects: let pyZipObjectType

quitCompat:

compat: proc quitCompat(e: string)

raisePyFormatExc:

strformat: template raisePyFormatExc(e: PyBaseErrorObject)

raiseSyntaxError:

rangeLen:

rangeLen: proc rangeLen[I](start, stop, step: I): I

rawEq:

hash: proc rawEq(obj1, obj2: PyObject): bool

rawHash:

hash: proc rawHash(obj: PyObject): Hash

readLine:

fileio: proc readLine(stdinF, stdoutF: File; prompt: string): string

readLineCompat:

compat: template readLineCompat(prompt): string

real:

decl: template real(self: PyComplexObject): float

realPyComplexObjectGetter:

complexobjectImpl: proc realPyComplexObjectGetter(selfNoCast: PyObject): PyObject

realPyComplexObjectSetter:

complexobjectImpl: proc realPyComplexObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

regfunc:

utils: template regfunc(f)

registerBltinMethod:

register_bltins:

bltinmodule: proc register_bltins()

register_compile_eval_exec:

compile_eval_exec: template register_compile_eval_exec()

register_globals_locals_vars:

globals_locals_vars: template register_globals_locals_vars()

register_io:

io: template register_io()

register_iter_objects:

iterobjects: template register_iter_objects()

register_iterops:

iterops: template register_iterops()

register_ops:

ops: template register_ops()

register_unarys:

unarys: template register_unarys()

regobj:

utils: template regobj(f)

release_bufferPyInstanceObjectMagic:

classobject: proc release_bufferPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

removeprefix:

removeprefixPybytearrayObjectMethod:

byteobjectsImpl: proc removeprefixPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

removeprefixPybytesObjectMethod:

byteobjectsImpl: proc removeprefixPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

removeprefixPystrObjectMethod:

pkgs: proc removeprefixPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

removePybytearrayObjectMethod:

byteobjectsImpl: proc removePybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

removePyListObjectMethod:

listobject: proc removePyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

removePySetObjectMethod:

setobject: proc removePySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

removesuffix:

removesuffixPybytearrayObjectMethod:

byteobjectsImpl: proc removesuffixPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

removesuffixPybytesObjectMethod:

byteobjectsImpl: proc removesuffixPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

removesuffixPystrObjectMethod:

pkgs: proc removesuffixPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

Repeat:

grammar: enum Repeat

replace:

replacePybytearrayObjectMethod:

byteobjectsImpl: proc replacePybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

replacePybytesObjectMethod:

byteobjectsImpl: proc replacePybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

replacePyStrObjectMethod:

meth: proc replacePyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

repr:

reprDefault:

strings: proc reprDefault(self: PyObject): PyObject

reprLock:

pyobject: macro reprLock(code: untyped): untyped

reprLockWithMsg:

pyobject: macro reprLockWithMsg(s: string; code: untyped): untyped

reprLockWithMsgExpr:

pyobject: macro reprLockWithMsgExpr(s: untyped; code: untyped): untyped

reprPyBaseExceptionObjectMagic:

exceptionsImpl: proc reprPyBaseExceptionObjectMagic(selfNoCast: PyObject): PyObject

reprPyBoolObjectMagic:

boolobjectImpl: proc reprPyBoolObjectMagic(selfNoCast: PyObject): PyObject

reprPybytearrayObjectMagic:

byteobjectsImpl: proc reprPybytearrayObjectMagic(selfNoCast: PyObject): PyObject

reprPybytesObjectMagic:

byteobjectsImpl: proc reprPybytesObjectMagic(selfNoCast: PyObject): PyObject

reprPyCodeObjectMagic:

codeobject: proc reprPyCodeObjectMagic(selfNoCast: PyObject): PyObject

reprPyComplexObjectMagic:

complexobjectImpl: proc reprPyComplexObjectMagic(selfNoCast: PyObject): PyObject

reprPyDictObjectMagic:

dictobject: proc reprPyDictObjectMagic(selfNoCast: PyObject): PyObject

reprPyDictProxyObjectMagic:

dictproxyobject: proc reprPyDictProxyObjectMagic(selfNoCast: PyObject): PyObject

reprPyEllipsisObjectMagic:

sliceobject: proc reprPyEllipsisObjectMagic(selfNoCast: PyObject): PyObject

reprPyFloatObjectMagic:

floatobject: proc reprPyFloatObjectMagic(selfNoCast: PyObject): PyObject

reprPyFrameLocalsProxyObjectMagic:

frameobject: proc reprPyFrameLocalsProxyObjectMagic(selfNoCast: PyObject): PyObject

reprPyFrameObjectMagic:

frameobject: proc reprPyFrameObjectMagic(selfNoCast: PyObject): PyObject

reprPyFrozenSetObjectMagic:

setobject: proc reprPyFrozenSetObjectMagic(selfNoCast: PyObject): PyObject

reprPyImportErrorObjectMagic:

exceptionsImpl: proc reprPyImportErrorObjectMagic(selfNoCast: PyObject): PyObject

reprPyInstanceObjectMagic:

classobject: proc reprPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

reprPyInterpolationObjectMagic:

interpolationobject: proc reprPyInterpolationObjectMagic(selfNoCast: PyObject): PyObject

reprPyIntObjectMagic:

intobjectImpl: proc reprPyIntObjectMagic(selfNoCast: PyObject): PyObject

reprPyListObjectMagic:

listobject: proc reprPyListObjectMagic(selfNoCast: PyObject): PyObject

reprPyNamespaceObjectMagic:

namespaceobject: proc reprPyNamespaceObjectMagic(selfNoCast: PyObject): PyObject

reprPyNoneObjectMagic:

noneobject: proc reprPyNoneObjectMagic(selfNoCast: PyObject): PyObject

reprPyNotImplementedObjectMagic:

notimplementedobject: proc reprPyNotImplementedObjectMagic(selfNoCast: PyObject): PyObject

reprPyRangeObjectMagic:

rangeobject: proc reprPyRangeObjectMagic(selfNoCast: PyObject): PyObject

reprPySetObjectMagic:

setobject: proc reprPySetObjectMagic(selfNoCast: PyObject): PyObject

reprPySliceObjectMagic:

sliceobjectImpl: proc reprPySliceObjectMagic(selfNoCast: PyObject): PyObject

reprPyStrObjectMagic:

meth: proc reprPyStrObjectMagic(selfNoCast: PyObject): PyObject

reprPyStructSequenceObjectMagic:

structseq: proc reprPyStructSequenceObjectMagic(selfNoCast: PyObject): PyObject

reprPyTupleObjectMagic:

tupleobject: proc reprPyTupleObjectMagic(selfNoCast: PyObject): PyObject

reprPyTypeObjectMagic:

typeobject: proc reprPyTypeObjectMagic(selfNoCast: PyObject): PyObject

reserveNameSet:

token: const reserveNameSet

reset:

byteobjects: proc reset(self: var PyBytesWriter; cap: int = 0)

retIfExc:

retInvIntCall:

ops: template retInvIntCall(strObj: PyObject; base: SomeInteger)

retTypeError:

utils: template retTypeError(body): untyped

retValueErrorAscii:

utils: template retValueErrorAscii(body): untyped

retZeroDiv:

numobjects_comm: template retZeroDiv()

reversedPyInstanceObjectMagic:

classobject: proc reversedPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

reversePybytearrayObjectMethod:

byteobjectsImpl: proc reversePybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

reversePyListObjectMethod:

listobject: proc reversePyListObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rfind:

rfindPybytearrayObjectMethod:

byteobjectsImpl: proc rfindPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rfindPybytesObjectMethod:

byteobjectsImpl: proc rfindPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rfindPyStrObjectMethod:

meth: proc rfindPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rindexPybytearrayObjectMethod:

byteobjectsImpl: proc rindexPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rindexPybytesObjectMethod:

byteobjectsImpl: proc rindexPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rindexPyStrObjectMethod:

meth: proc rindexPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rjust:

rjustPybytearrayObjectMethod:

byteobjectsImpl: proc rjustPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rjustPybytesObjectMethod:

byteobjectsImpl: proc rjustPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rjustPystrObjectMethod:

pkgs: proc rjustPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

round:

rpartition:

pkgs: proc rpartition(self: PyStrObject; sep: PyStrObject): PyTupleObject

rpartitionPybytearrayObjectMethod:

byteobjectsImpl: proc rpartitionPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rpartitionPybytesObjectMethod:

byteobjectsImpl: proc rpartitionPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rpartitionPyStrObjectMethod:

meth: proc rpartitionPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rshiftPyInstanceObjectMagic:

classobject: proc rshiftPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

rshiftPyIntObjectMagic:

intobjectImpl: proc rshiftPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

rsplit:

rsplitPybytearrayObjectMethod:

byteobjectsImpl: proc rsplitPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rsplitPybytesObjectMethod:

byteobjectsImpl: proc rsplitPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rsplitPyStrObjectMethod:

meth: proc rsplitPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rstrip:

rstripPybytearrayObjectMethod:

byteobjectsImpl: proc rstripPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rstripPybytesObjectMethod:

byteobjectsImpl: proc rstripPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

rstripPyStrObjectMethod:

meth: proc rstripPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

RtArray:

rawMem: object RtArray

runCode:

neval: proc runCode(co: PyCodeObject; globals = newPyDict(); locals: PyObject = nil): PyObject

run_eval_code_with_audit:

utils: proc run_eval_code_with_audit(co: PyCodeObject; globals: PyDictObject; locals: PyObject): PyObject

run_file:

main: proc run_file(config: PyConfig): int

Scope:

symtable: enum Scope

setattrPyInstanceObjectMagic:

classobject: proc setattrPyInstanceObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

set_characters_written:

exceptionsImpl: proc set_characters_written(self: PyOSErrorObject; arg: PyObject): PyBaseErrorObject

setdefault:

ops: proc setdefault(self: PyDictObject; key: PyObject; defVal: PyObject = pyNone): PyObject

setdefaultPyDictObjectMethod:

dictobject: proc setdefaultPyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

setDefaultRef:

set_int_max_str_digitsPySysModuleObjectMethod:

sysmodule: proc set_int_max_str_digitsPySysModuleObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

setItem:

dictobject: proc setItem(dict: PyDictObject; key, value: PyObject): PyBaseErrorObject

setitemPybytearrayObjectMagic:

byteobjectsImpl: proc setitemPybytearrayObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

setitemPyDictObjectMagic:

dictobject: proc setitemPyDictObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

setitemPyInstanceObjectMagic:

classobject: proc setitemPyInstanceObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

setitemPyListObjectMagic:

listobject: proc setitemPyListObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

setLen:

byteobjects: proc setLen(self: PyByteArrayObject; n: int)

setPyFormatExc:

strformat: template setPyFormatExc(e: PyBaseErrorObject)

setPyGetSetDescrObjectMagic:

descrobject: proc setPyGetSetDescrObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

setPyInstanceObjectMagic:

classobject: proc setPyInstanceObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

setPyMemberDescrObjectMagic:

descrobjectImpl: proc setPyMemberDescrObjectMagic(selfNoCast: PyObject; arg1: PyObject; arg2: PyObject): PyObject

setSignNegative:

signbit: template setSignNegative(self: PyIntObject): untyped

setString:

SET_SYS:

set_tb_next:

exceptionsImpl: proc set_tb_next(self: PyTracebackObject; value: PyObject): PyBaseExceptionObject

setTraceback:

traceback: proc setTraceback(excp: PyBaseExceptionObject; tb: PyObject): PyBaseErrorObject

sign:

decl: template sign(self: PyIntObject): IntSign

SingleThread:

sizeofIntFlag:

intflags: const sizeofIntFlag

sort:

sorted:

iterops: proc sorted(sequ: PyObject; key: PyObject = pyNone; reversed = false): PyObject

split:

splitlines:

pkgs: proc splitlines(self: PyStrObject; keepends = false): PyListObject

splitlinesPybytearrayObjectMethod:

byteobjectsImpl: proc splitlinesPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

splitlinesPybytesObjectMethod:

byteobjectsImpl: proc splitlinesPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

splitlinesPyStrObjectMethod:

meth: proc splitlinesPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

splitPybytearrayObjectMethod:

byteobjectsImpl: proc splitPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

splitPybytesObjectMethod:

byteobjectsImpl: proc splitPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

splitPyStrObjectMethod:

meth: proc splitPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

sq_item:

wraps: proc sq_item(self: PyObject; i: int): PyObject

sq_length:

wraps: proc sq_length(o: PyObject; resi: var int): PyBaseErrorObject

startAsInt:

sliceobjectImpl: proc startAsInt[I: PyIntObject | int](slice: PySliceObject; size: I): I

startKwOnly:

paramsMeta: template startKwOnly()

startswith:

startswithPybytearrayObjectMethod:

byteobjectsImpl: proc startswithPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

startswithPybytesObjectMethod:

byteobjectsImpl: proc startswithPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

startswithPyStrObjectMethod:

meth: proc startswithPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

SteKind:

symtable: enum SteKind

stepAsInt:

sliceobjectImpl: proc stepAsInt(slice: PySliceObject): int

stepAsLong:

sliceobjectImpl: proc stepAsLong(slice: PySliceObject): PyIntObject

stopAsInt:

sliceobjectImpl: proc stopAsInt[I: PyIntObject | int](slice: PySliceObject; size: I): I

Str:

str: type Str

strDefault:

strings: proc strDefault(self: PyObject): PyObject

StrEmpty:

str: const StrEmpty

string_kind_t:

lexerTypes: enum string_kind_t

strip:

stripPybytearrayObjectMethod:

byteobjectsImpl: proc stripPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

stripPybytesObjectMethod:

byteobjectsImpl: proc stripPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

stripPyStrObjectMethod:

meth: proc stripPyStrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

strPyBaseExceptionObjectMagic:

exceptionsImpl: proc strPyBaseExceptionObjectMagic(selfNoCast: PyObject): PyObject

strPyDictProxyObjectMagic:

dictproxyobject: proc strPyDictProxyObjectMagic(selfNoCast: PyObject): PyObject

strPyFloatObjectMagic:

floatobject: proc strPyFloatObjectMagic(selfNoCast: PyObject): PyObject

strPyImportErrorObjectMagic:

exceptionsImpl: proc strPyImportErrorObjectMagic(selfNoCast: PyObject): PyObject

strPyInstanceObjectMagic:

classobject: proc strPyInstanceObjectMagic(selfNoCast: PyObject): PyObject

strPyKeyErrorObjectMagic:

exceptionsImpl: proc strPyKeyErrorObjectMagic(selfNoCast: PyObject): PyObject

strPyOSErrorObjectMagic:

exceptionsImpl: proc strPyOSErrorObjectMagic(selfNoCast: PyObject): PyObject

strPyStrObjectMagic:

meth: proc strPyStrObjectMagic(selfNoCast: PyObject): PyObject

strPySyntaxErrorObjectMagic:

exceptionsImpl: proc strPySyntaxErrorObjectMagic(selfNoCast: PyObject): PyObject

strPyTypeObjectMagic:

typeobject: proc strPyTypeObjectMagic(selfNoCast: PyObject): PyObject

strPyWarningMessageObjectMagic:

warningobject: proc strPyWarningMessageObjectMagic(selfNoCast: PyObject): PyObject

strTokenMap:

token: let strTokenMap

subErrs:

sub: var subErrs

subPyComplexObjectMagic:

complexobjectImpl: proc subPyComplexObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

subPyFloatObjectMagic:

floatobject: proc subPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

subPyFrozenSetObjectMagic:

setobject: proc subPyFrozenSetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

subPyInstanceObjectMagic:

classobject: proc subPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

subPyIntObjectMagic:

intobjectImpl: proc subPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

subPySetObjectMagic:

setobject: proc subPySetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

substring:

meth: proc substring(self: PyStrObject; start, stop: int; res: var PyStrObject): PyIndexErrorObject

substringUnsafe:

meth: proc substringUnsafe(self: PyStrObject; start, stop: int): PyStrObject

subtype_dealloc:

typeobject: proc subtype_dealloc[P](self)

successGrammarNode:

grammar: let successGrammarNode

SUgetframePySysModuleObjectMethod:

sysmodule: proc SUgetframePySysModuleObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

sum:

sums: proc sum(iterable: PyObject; start {.startKwOnly.}: PyObject = nil): PyObject

SUnpython_reprPyCodeObjectMethod:

codeobject: proc SUnpython_reprPyCodeObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

symmetric_difference:

symmetric_differencePyFrozenSetObjectMethod:

setobject: proc symmetric_differencePyFrozenSetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

symmetric_differencePySetObjectMethod:

setobject: proc symmetric_differencePySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

symmetric_difference_updatePySetObjectMethod:

setobject: proc symmetric_difference_updatePySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

SymTable:

symtable: type SymTable

SymTableEntry:

symtable: type SymTableEntry

SyntaxError:

utils: type SyntaxError

sys:

sysmodule_instance: var sys

sysdict:

attrs: template sysdict(): PyDictObject

sysexit:

sysmodule: proc sysexit(args: openArray[PyObject]; kwargs: PyObject): PyObject

tb_nextPyTracebackObjectGetter:

exceptionsImpl: proc tb_nextPyTracebackObjectGetter(selfNoCast: PyObject): PyObject

tb_nextPyTracebackObjectSetter:

exceptionsImpl: proc tb_nextPyTracebackObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

ternary_func:

op_helpers: template ternary_func(op; magicop; opname)

TernaryMethod:

pyobjectBase: type TernaryMethod

times:

tupleobjectImpl: proc times[T](s: openArray[T]; n: int): seq[T]

title:

titlePybytearrayObjectMethod:

byteobjectsImpl: proc titlePybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

titlePybytesObjectMethod:

byteobjectsImpl: proc titlePybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

titlePystrObjectMethod:

pkgs: proc titlePystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

tnssInvalidStep:

sliceobjectImpl: ToNimSliceState.tnssInvalidStep

tnssOk:

sliceobjectImpl: ToNimSliceState.tnssOk

tnssOverflow:

sliceobjectImpl: ToNimSliceState.tnssOverflow

toBool:

complexobjectImpl: proc toBool(self: PyComplexObject): PyBoolObject

to_bytes:

to_bytesPyIntObjectMethod:

intobjectImpl: proc to_bytesPyIntObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

TODO_locals:

neval: template TODO_locals(locals)

ops_toint: template toIntOrRetOF(vv: PyIntObject): int

Token:

token: enum Token

tokenize_and_cst_one:

apis: proc tokenize_and_cst_one(input: string; lexer: Lexer; rootCst: var ParseNode; exc: var PyBaseErrorObject; filename_obj: PyStrObject): bool

tokenizer_mode:

lexerTypes: object tokenizer_mode

tokenizer_mode_kind_t:

lexerTypes: enum tokenizer_mode_kind_t

TokenNode:

token: type TokenNode

TOK_FSTRING_MODE:

lexerTypes: tokenizer_mode_kind_t.TOK_FSTRING_MODE

TOK_REGULAR_MODE:

lexerTypes: tokenizer_mode_kind_t.TOK_REGULAR_MODE

toNimComplex:

decl: proc toNimComplex(self: PyComplexObject): Complex[float]

toNimSlice:

ToNimSliceState:

sliceobjectImpl: enum ToNimSliceState

toObjSeq:

pyobjectBase: converter toObjSeq[Py: PyObject](s: seq[Py]): seq[PyObject]

toPyDict:

frameobject: proc toPyDict(f: PyFrameObject): PyDictObject

toPyTuple:

listobject: proc toPyTuple(tup: PyListObject): PyTupleObject

toRunes:

stringobject: proc toRunes(self: UnicodeVariant): seq[Rune]

toSomeSignedInt:

ops_toint: proc toSomeSignedInt[I: SomeSignedInt](pyInt: PyIntObject; overflow: var IntSign): I

toSomeSignedIntUnsafe:

ops_toint: proc toSomeSignedIntUnsafe[T: SomeSignedInt](pyInt: PyIntObject): T

toSomeUnsignedInt:

ops_toint: proc toSomeUnsignedInt[U: SomeUnsignedInt](pyInt: PyIntObject; overflow: var IntSign): U

toStringBy:

codeobject: proc toStringBy(t: tuple[opCode: OpCode, opArg: OpArg]; code: PyCodeObject; otherCodes: var seq[PyCodeObject]): string

toStringCheckThreshold:

ops: proc toStringCheckThreshold(a: PyIntObject; v: var string): PyBaseErrorObject

toTypeObject:

pyobject: macro toTypeObject[O: PyObject](tp: typedesc[O]): PyTypeObject

toUInt:

toval:

tovalAux:

tovalUtils: macro tovalAux(res: PyObject; v): PyBaseErrorObject

tp_free:

pyobjectBase: template tp_free(self: PyTypeObject; op: var PyObjectObj)

tpGetter:

pyobject: macro tpGetter(tp, methodName: untyped): untyped

tpMagic:

pyobject: macro tpMagic(tp, methodName: untyped): untyped

tpMethod:

pyobject: macro tpMethod(tp, methodName: untyped): untyped

tpSetter:

pyobject: macro tpSetter(tp, methodName: untyped): untyped

traceback:

traceback: proc traceback(excp: PyBaseExceptionObject): PyTracebackObject

traceback=:

tracebackPyBaseExceptionObjectGetter:

traceback: proc tracebackPyBaseExceptionObjectGetter(selfNoCast: PyObject): PyObject

tracebackPyBaseExceptionObjectSetter:

traceback: proc tracebackPyBaseExceptionObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

tracebackPyExceptionObjectGetter:

traceback: proc tracebackPyExceptionObjectGetter(selfNoCast: PyObject): PyObject

tracebackPyExceptionObjectSetter:

traceback: proc tracebackPyExceptionObjectSetter(selfNoCast: PyObject; other: PyObject): PyObject

transformDecimalAndSpaceToASCII:

decimalAndSpace: proc transformDecimalAndSpaceToASCII(unicode: PyStrObject): string

truedivPyComplexObjectMagic:

complexobjectImpl: proc truedivPyComplexObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

truedivPyFloatObjectMagic:

floatobject: proc truedivPyFloatObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

truedivPyInstanceObjectMagic:

classobject: proc truedivPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

truedivPyIntObjectMagic:

intobjectImpl: proc truedivPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

truncedTypeName:

descrobject: proc truncedTypeName(descr: PyCommonMethodDescrObject): string

tupleSeqToString:

tupleobject: proc tupleSeqToString(ss: openArray[UnicodeVariant]): UnicodeVariant

typeCheck:

subtype: proc typeCheck(ob: PyObject; tp: PyTypeObject): bool

type_error:

helpers: proc type_error(s: string): PyBaseErrorObject

type_errorn:

helpers: proc type_errorn(nstyleS: string; o: PyObject): PyBaseErrorObject

type_module:

getters: proc type_module(typ: PyTypeObject): PyObject

typeName:

pyobjectBase: template typeName(o: PyObject): string

typeReady:

typeReadyImpl:

type_ready: proc typeReadyImpl(tp: PyTypeObject; initial: bool)

typeToAnyKind:

UnaryMethod:

pyobjectBase: type UnaryMethod

unhashable:

hash: proc unhashable(obj: PyObject): PyTypeErrorObject

UnicodeVariant:

stringobject: type UnicodeVariant

union:

unionPyFrozenSetObjectMethod:

setobject: proc unionPyFrozenSetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

unionPySetObjectMethod:

setobject: proc unionPySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

unpackOptArgs:

unreachable:

utils: template unreachable(msg = ShouldnotHere)

update:

dictobject: proc update(d1, d2: PyDictObject)

updateImpl:

updatePyDictObjectMethod:

dictobjectImpl: proc updatePyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

updatePySetObjectMethod:

setobject: proc updatePySetObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

updateSlots:

classobject: macro updateSlots(tp: PyTypeObject; dict: PyDictObject): untyped

upper:

upperPybytearrayObjectMethod:

byteobjectsImpl: proc upperPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

upperPybytesObjectMethod:

byteobjectsImpl: proc upperPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

upperPystrObjectMethod:

pkgs: proc upperPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

value:

ast: proc value(self: Asdlkeyword): Asdlexpr

values:

dictobject: iterator values(dict: PyDictObject): PyObject

valuesPyDictObjectMethod:

dictobject: proc valuesPyDictObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

vars:

globals_locals_vars: proc vars(v: PyObject = nil): PyObject

vectorcallMethod:

call: proc vectorcallMethod(name: PyStrObject; args: openArray[PyObject]; kwnames: PyDictObject = nil): PyObject

Version:

versionInfo: const Version

VersionInfodesc:

infos: const VersionInfodesc

VersionInfoType:

infos: var VersionInfoType

warnEx:

warnings: proc warnEx(category: PyTypeObject; message: string | PyStrObject; stacklevel: int = 1): PyBaseErrorObject

warnExplicit:

warnings: proc warnExplicit(category: PyTypeObject; message: string | PyStrObject; filename: string; lineno: int; module: PyStrObject = nil; registry: PyDictObject = nil): PyBaseErrorObject

withinFStringExpr:

lexerTypes: proc withinFStringExpr(tok: tokenizer_mode): bool

withNextMode:

withNoRecusiveCallOrRetE:

pycore_ceval_rec: template withNoRecusiveCallOrRetE(where: cstring; body)

withSetitem:

tupleobjectImpl: template withSetitem(self: PyTupleObject; acc; body)

withValue:

wrapExportSincepy:

version: macro wrapExportSincepy(major, minor: static int; sym: typed)

xorPyBoolObjectMagic:

boolobjectImpl: proc xorPyBoolObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

xorPyFrozenSetObjectMagic:

setobject: proc xorPyFrozenSetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

xorPyInstanceObjectMagic:

classobject: proc xorPyInstanceObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

xorPyIntObjectMagic:

intobjectImpl: proc xorPyIntObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

xorPySetObjectMagic:

setobject: proc xorPySetObjectMagic(selfNoCast: PyObject; other: PyObject): PyObject

zero:

signbit: template zero(self: PyIntObject): untyped

zfill:

zfillPybytearrayObjectMethod:

byteobjectsImpl: proc zfillPybytearrayObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

zfillPybytesObjectMethod:

byteobjectsImpl: proc zfillPybytesObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject

zfillPystrObjectMethod:

pkgs: proc zfillPystrObjectMethod(selfNoCast: PyObject; args: openArray[PyObject] = @[]; kwargs: PyKwArgType = nil): PyObject