Index

Modules: pylib, pylib/Lib/io, pylib/Lib/ncodec, pylib/Lib/os_impl/common, pylib/Lib/os_impl/consts, pylib/Lib/os_impl/posix_like/isatty, pylib/Lib/os_impl/posix_like/open_close, pylib/Lib/os_impl/posix_like/truncate, pylib/Lib/timeit, pylib/Lib/warnings, pylib/builtins, pylib/builtins/asciiImpl, pylib/builtins/attr, pylib/builtins/complex, pylib/builtins/dict, pylib/builtins/dict_decl, pylib/builtins/input, pylib/builtins/iter_next, pylib/builtins/iters, pylib/builtins/list, pylib/builtins/list_decl, pylib/builtins/mathfunc, pylib/builtins/misc, pylib/builtins/modPow, pylib/builtins/oopFuncs, pylib/builtins/print, pylib/builtins/private/iterGen, pylib/builtins/private/mathutils, pylib/builtins/pyhashes, pylib/builtins/pyrange, pylib/builtins/pyslice, pylib/builtins/reprImpl, pylib/builtins/set, pylib/builtins/set_decl, pylib/collections_abc, pylib/io, pylib/io_abc, pylib/noneType, pylib/numTypes, pylib/ops, pylib/private/backendMark, pylib/private/trans_imp, pylib/pybool, pylib/pybytearray, pylib/pybytes, pylib/pybytes/bytesbltins, pylib/pybytes/bytesimpl, pylib/pybytes/bytesmeth, pylib/pybytes/bytesprefix, pylib/pybytes/hex, pylib/pybytes/split/common, pylib/pybytes/split/reimporter, pylib/pybytes/split/rsplit, pylib/pybytes/split/rsplit_whitespace, pylib/pybytes/split/split, pylib/pybytes/split/split_whitespace, pylib/pybytes/split/splitlinesIter, pylib/pybytes/strip, pylib/pybytes/translate, pylib/pyerrors, pylib/pyerrors/lkuperr, pylib/pyerrors/oserr, pylib/pyerrors/rterr, pylib/pyerrors/simperr, pylib/pystring, pylib/pystring/consts, pylib/pystring/format, pylib/pystring/fstring, pylib/pystring/split/common, pylib/pystring/split/reimporter, pylib/pystring/split/rsplit, pylib/pystring/split/rsplit_whitespace, pylib/pystring/split/split, pylib/pystring/split/split_whitespace, pylib/pystring/split/splitlinesIter, pylib/pystring/strbltins, pylib/pystring/strimpl, pylib/pystring/strip, pylib/pystring/strmeth, pylib/pystring/strops, pylib/pystring/strprefix, pylib/pystring/translate, pylib/pysugar, pylib/pysugar/class, pylib/pysugar/pydef, pylib/pysugar/pywith, pylib/pysugar/stmt/class, pylib/pysugar/stmt/decorator, pylib/pysugar/stmt/frame, pylib/pysugar/stmt/funcSignature, pylib/pysugar/stmt/pydef, pylib/pysugar/stmt/pyraise, pylib/pysugar/stmt/tonim, pylib/pysugar/stmt/unpack, pylib/pysugar/tonim, pylib/pysugar/unpack, pylib/stringlib/errHandle, pylib/stringlib/format, pylib/stringlib/formats, pylib/stringlib/meth, pylib/stringlib/replaceWithCount, pylib/stringlib/split/common, pylib/stringlib/split/reimporter, pylib/stringlib/split/rsplit_whitespace, pylib/stringlib/split/split_whitespace, pylib/stringlib/split/splitlinesIter, pylib/translateEscape, pylib/version.

API symbols

`$`:

• complex: proc `$`(z: PyComplex): string
• dict: template `$`(self: PyDict): string
• dict: template `$`(view`gensym3: PyDictItemView): string
• dict: template `$`(view`gensym1: PyDictKeyView): string
• dict: template `$`(view`gensym2: PyDictValueView): string
• list: template `$`[T](ls: PyList[T]): string
• pyrange: proc `$`[T](rng: PyRange[T]): string
• set_decl: proc `$`(self: PyFrozenSet): string
• set_decl: proc `$`(self: PySet): string
• io_abc: proc `$`(p: CanIOOpenT): string
• io_abc: proc `$`(p: PathLike): string
• pybool: proc `$`(self: PyBool): string
• pybytearray: proc `$`(self: PyByteArray): string
• bytesimpl: proc `$`(self: PyBytes): string
• strimpl: proc `$`(self: PyStr): string
• translate: template `$`(table: TranslateTable): string

`%=`:

• ops: template `%=`(self: var SomeNumber; x: SomeNumber)

`%`:

• ops: proc `%`[T: SomeNumber](a, b: T): T
• ops: template `%`[A: SomeFloat; B: SomeInteger](a: A; b: B): A
• ops: template `%`[A: SomeInteger; B: SomeFloat](a: A; b: B): B

`&=`:

• set: proc `&=`[H; S: SomeSet[H]](self: var SomePySet[H]; s: S)

`&`:

• set: template `&`[H; M: SomePySet[H]; S: SomePySet[H]](self: M; s: S): M | S

`'j`:

• complex: template `'j`(lit: string): PyComplex

`**=`:

• ops: template `**=`(a: var SomeNumber; b: SomeNumber)

`**`:

• ops: template `**`[A: SomeFloat; B: SomeInteger](a: A; b: B): A
• ops: template `**`[A: SomeInteger; B: SomeFloat](a: A; b: B): B
• ops: template `**`[T](a: T; b: Natural): T
• ops: template `**`[T: SomeFloat](a, b: T): T

`*=`:

• complex: template `*=`(a`gensym10, b`gensym10: PyComplex): untyped
• list: proc `*=`[T](self: var PyList[T]; n: int)
• pybytearray: proc `*=`(mself: PyByteArray; n: int)

`*`:

• complex: template `*`[I: SomeInteger; T](z`gensym15: PyComplex[T]; a`gensym15: I): PyComplex[T]
• complex: template `*`[T: SomeFloat](z`gensym15: PyComplex[T]; a`gensym15: T): PyComplex[T]
• complex: template `*`[I: SomeInteger; T](a`gensym15: I; z`gensym15: PyComplex[T]): PyComplex[T]
• complex: template `*`(a`gensym6, b`gensym6: PyComplex): PyComplex
• complex: template `*`[T: SomeFloat](a`gensym15: T; z`gensym15: PyComplex[T]): PyComplex[T]
• list: proc `*`[T](n: Natural; ls: PyList[T]): PyList[T]
• list: template `*`[T](ls: PyList[T]; n: Natural): PyList[T]
• bytesmeth: template `*`(i: int; a: PyBytes): PyBytes
• bytesmeth: template `*`(a: PyBytes; i: int): PyBytes
• strmeth: template `*`(i: int; a: StringLike): PyStr
• strmeth: template `*`(a: StringLike; i: int): PyStr

`+=`:

• complex: template `+=`(a`gensym8, b`gensym8: PyComplex): untyped
• list: proc `+=`[T](self: var PyList[T]; ls: openArray[T])
• list: proc `+=`[T](self: var PyList[T]; ls: PyList[T])
• pybytearray: proc `+=`(mself: PyByteArray; other: BytesLike)
• bytesimpl: proc `+=`(mself; s: char)
• bytesimpl: proc `+=`(mself; s: PyBytes)
• bytesimpl: proc `+=`(mself; s: string)
• strimpl: proc `+=`(mself; s: char)
• strimpl: proc `+=`(mself; s: PyStr)
• strimpl: proc `+=`(mself; s: string)

`+`:

• complex: template `+`[I: SomeInteger; T](z`gensym13: PyComplex[T]; a`gensym13: I): PyComplex[T]
• complex: template `+`[T: SomeFloat](z`gensym13: PyComplex[T]; a`gensym13: T): PyComplex[T]
• complex: template `+`[I: SomeInteger; T](a`gensym13: I; z`gensym13: PyComplex[T]): PyComplex[T]
• complex: template `+`(a`gensym4, b`gensym4: PyComplex): PyComplex
• complex: template `+`[T: SomeFloat](a`gensym13: T; z`gensym13: PyComplex[T]): PyComplex[T]
• list: proc `+`[T](self: PyList[T]; x: openArray[T]): PyList[T]
• list: template `+`[T](self: var PyList[T]; x: PyList[T]): PyList[T]
• bytesimpl: proc `+`(self: PyBytes; o: char): PyBytes
• bytesimpl: proc `+`(self: PyBytes; o: PyBytes): PyBytes
• bytesimpl: proc `+`(self: PyBytes; o: string): PyBytes
• bytesimpl: proc `+`(o: char; self: PyBytes): PyBytes
• bytesimpl: proc `+`(o: string; self: PyBytes): PyBytes
• strimpl: proc `+`(self: PyStr; s: PyStr): PyStr
• strimpl: proc `+`(self: PyStr; s: StringLike): PyStr

`-=`:

• complex: template `-=`(a`gensym9, b`gensym9: PyComplex): untyped
• set: proc `-=`[H; S: SomeSet[H]](self: var SomePySet[H]; s: S)

`-`:

• complex: template `-`[I: SomeInteger; T](z`gensym14: PyComplex[T]; a`gensym14: I): PyComplex[T]
• complex: template `-`[T: SomeFloat](z`gensym14: PyComplex[T]; a`gensym14: T): PyComplex[T]
• complex: template `-`[I: SomeInteger; T](a`gensym14: I; z`gensym14: PyComplex[T]): PyComplex[T]
• complex: template `-`(a`gensym5, b`gensym5: PyComplex): PyComplex
• complex: template `-`[T: SomeFloat](a`gensym14: T; z`gensym14: PyComplex[T]): PyComplex[T]
• set: proc `-`[H](self: PyFrozenSet[H]; o: SomePySet[H]): PyFrozenSet[H]
• set: proc `-`[H](self: PySet[H]; o: PyFrozenSet[H]): PyFrozenSet[H]
• set: proc `-`[H](self, o: PySet[H]): PySet[H]

`//=`:

• ops: template `//=`[A, B: SomeFloat | SomeInteger](a: var A; b: B)

`//`:

• ops: proc `//`[A, B: SomeFloat | SomeInteger](a: A; b: B): SomeNumber

`/=`:

• complex: template `/=`(a`gensym11, b`gensym11: PyComplex): untyped

`/`:

• complex: template `/`[I: SomeInteger; T](z`gensym16: PyComplex[T]; a`gensym16: I): PyComplex[T]
• complex: template `/`[T: SomeFloat](z`gensym16: PyComplex[T]; a`gensym16: T): PyComplex[T]
• complex: template `/`[I: SomeInteger; T](a`gensym16: I; z`gensym16: PyComplex[T]): PyComplex[T]
• complex: template `/`(a`gensym7, b`gensym7: PyComplex): PyComplex
• complex: template `/`[T: SomeFloat](a`gensym16: T; z`gensym16: PyComplex[T]): PyComplex[T]
• ops: template `/`(x: SomeInteger; y: SomeInteger): float

`:=`:

• pysugar: template `:=`(name, value: untyped): untyped

`<<=`:

• ops: template `<<=`[I: SomeInteger](a, b: I)

`<<`:

• ops: template `<<`[I: SomeInteger](a, b: I): I

`<=`:

• pyslice: proc `<=`(self`gensym6: PySlice; o`gensym6: PySlice): bool
• set: proc `<=`[H](s: set[H]; self: SomePySet[H]): bool
• set: proc `<=`[H](self: SomePySet[H]; s: set[H]): bool
• set_decl: proc `<=`(self, o: SomePySet): int
• ops: template `<=`[A: SomeInteger; B: SomeFloat](a: A; b: B): bool
• ops: template `<=`[A: SomeFloat; B: SomeInteger](a: A; b: B): bool
• pybytearray: proc `<=`(self: PyByteArray; other: PyByteArray): bool
• pybytearray: proc `<=`(self: PyByteArray; other: PyBytes): bool

`<>`:

• ops: template `<>`[A: SomeInteger; B: SomeFloat](a: A; b: B): bool
• ops: template `<>`[A: SomeFloat; B: SomeInteger](a: A; b: B): bool
• strops: template `<>`[A: StringLike; B: StringLike](a: A; b: B): bool

`<`:

• pyslice: proc `<`(self`gensym3: PySlice; o`gensym3: PySlice): bool
• set: proc `<`[H](s: set[H]; self: SomePySet[H]): bool
• set: proc `<`[H](self: SomePySet[H]; s: set[H]): bool
• set_decl: proc `<`(self, o: SomePySet): int
• ops: template `<`[A: SomeInteger; B: SomeFloat](a: A; b: B): bool
• ops: template `<`[A: SomeFloat; B: SomeInteger](a: A; b: B): bool
• pybytearray: proc `<`(self: PyByteArray; other: PyByteArray): bool
• pybytearray: proc `<`(self: PyByteArray; other: PyBytes): bool

`==`:

• complex: template `==`(a`gensym12, b`gensym12: PyComplex): untyped
• dict: proc `==`[A, B](self, other: PyDict[A, B]): bool
• list: proc `==`[T](self: PyList[T]; o: openArray[T]): bool
• list: proc `==`[T](self: PyList[T]; o: PyList[T]): bool
• list: proc `==`[T](self: PyList[T]; o: seq[T]): bool
• list: template `==`[T](o: openArray[T]; self: PyList[T]): bool
• list: template `==`[T](o: seq[T]; self: PyList[T]): bool
• pyslice: proc `==`(self: PySlice; o: PySlice): bool
• set: proc `==`[H](s: set[H]; self: SomePySet[H]): bool
• set: proc `==`[H](self: SomePySet[H]; s: set[H]): bool
• set_decl: proc `==`(self, o: SomePySet): int
• collections_abc: proc `==`[K, V](a, b: Mapping[K, V]): bool
• ops: template `==`[A: SomeInteger; B: SomeFloat](a: A; b: B): bool
• ops: template `==`[A: SomeFloat; B: SomeInteger](a: A; b: B): bool
• ops: template `==`(a, b: typedesc): bool
• pybool: proc `==`(self: PyBool; opyb: PyBool): PyBool
• pybool: proc `==`(self: PyBool; b: bool): PyBool
• pybool: proc `==`(b: bool; self: PyBool): PyBool
• pybytearray: proc `==`(self: PyByteArray; other: PyByteArray): bool
• pybytearray: proc `==`(self: PyByteArray; other: PyBytes): bool
• bytesimpl: proc `==`(self: PyBytes; o: PyBytes): bool
• strimpl: proc `==`(self: PyStr; o: PyStr): bool
• strimpl: proc `==`(self: PyStr; o: string): bool
• strimpl: proc `==`(o: string; self: PyStr): bool

`>>=`:

• ops: template `>>=`[I: SomeInteger](a, b: I)

`>>`:

• ops: template `>>`[I: SomeInteger](a, b: I): I

`@`:

• list_decl: proc `@`[T](ls: PyList[T]): seq[T]
• bytesimpl: proc `@`(self: PyBytes): seq[char]

`[]=`:

• dict: proc `[]=`[A, B](t: PyDict[A, B]; key: A; val: sink B)
• list: proc `[]=`[T](self: var PyList[T]; s: BackwardsIndex; x: T)
• list: proc `[]=`[T](self: var PyList[T]; s: HSlice; x: Iterable[T])
• list: proc `[]=`[T](self: var PyList[T]; s: HSlice; x: openArray[T])
• list: proc `[]=`[T](self: var PyList[T]; s: HSlice; x: PyList[T])
• list: proc `[]=`[T](self: var PyList[T]; idx: int; x: T)
• list: proc `[]=`[T](self: var PyList[T]; s: PySlice; x: not Sequence[T] and Iterable[T])
• list: proc `[]=`[T](self: var PyList[T]; s: PySlice; x: Sequence[T])
• pybytearray: proc `[]=`(mself: PyByteArray; i: HSlice[int, BackwardsIndex]; val: BytesLike)
• pybytearray: proc `[]=`(mself: PyByteArray; i: int; val: int)
• pybytearray: proc `[]=`(mself: PyByteArray; i: Slice[int]; val: BytesLike)

`[]`:

• dict: proc `[]`[A, B](t: PyDict[A, B]; key: A): B
• list: proc `[]`[T](self: PyList[T]; s: BackwardsIndex): T
• list: proc `[]`[T](self: PyList[T]; s: HSlice): PyList[T]
• list: proc `[]`[T](self: PyList[T]; idx: int): T
• list: proc `[]`[T](self: PyList[T]; s: PySlice): PyList[T]
• pyrange: proc `[]`[T](x: PyRange[T]; y: Natural): T
• pybytearray: proc `[]`(self: PyByteArray; i: HSlice[int, BackwardsIndex]): PyByteArray
• pybytearray: proc `[]`(self: PyByteArray; i: Slice[int]): PyByteArray
• bytesimpl: proc `[]`(self: PyBytes; i: HSlice[int, BackwardsIndex]): PyBytes
• bytesimpl: proc `[]`(self: PyBytes; i: int): int
• bytesimpl: proc `[]`(self: PyBytes; i: Slice[int]): PyBytes
• strimpl: proc `[]`(self: PyStr; i: HSlice[int, BackwardsIndex]): PyStr
• strimpl: proc `[]`(self: PyStr; i: int): PyStr
• strimpl: proc `[]`(self: PyStr; i: Slice[int]): PyStr

`^`:

• set: template `^`[H; M: SomePySet[H]; S: SomePySet[H]](self: M; s: S): M | S

`and`:

• pybool: proc `and`(self: PyBool; opyb: PyBool): PyBool
• pybool: proc `and`[T: not PyBool and not bool](nself, npyb: T): T
• strimpl: template `and`(a, b: PyStr): PyStr

`discard`:

• set: proc `discard`[H](self: var PySet[H]; ele: H)

`is`:

• pybool: proc `is`(self: PyBool; opyb: PyBool): PyBool

`not`:

• pybool: proc `not`(self: PyBool): PyBool
• pybool: proc `not`[T: not PyBool and not bool](nself: T): PyBool
• bytesimpl: template `not`(s: PyBytes): bool
• strimpl: template `not`(s: PyStr): bool

`or`:

• pybool: proc `or`(self: PyBool; opyb: PyBool): PyBool
• pybool: proc `or`[T: not PyBool and not bool](nself, npyb: T): T
• bytesimpl: template `or`(a, b: PyBytes): PyBytes
• strimpl: template `or`(a, b: PyStr): PyStr

`xor`:

• pybool: proc `xor`(self: PyBool; opyb: PyBool): PyBool

`|=`:

• dict: proc `|=`(a, b: PyDict)
• set: proc `|=`[H; S: SomeSet[H]](self: var SomePySet[H]; s: S)
• consts: template `|=`(a, b: cint)

`|`:

• dict: proc `|`(a, b: PyDict): PyDict
• set: template `|`[H; M: SomePySet[H]; S: SomePySet[H]](self: M; s: S): M | S
• consts: template `|`(a, b: cint): cint

abs:

• complex: proc abs[T](z: PyComplex[T]): T

add:

• set: proc add[H](self: var PySet[H]; x: H)
• frame: proc add(mparser; ident: string)

all:

• pybool: proc all[T](iter: Iterable[T]): PyBool

allAlpha:

• meth: template allAlpha(a, isWhat, isNotWhat: typed; iter, firstItemGetter)

altsep:

• consts: let altsep

any:

• pybool: proc any[T](iter: Iterable[T]): PyBool

append:

• list: proc append[T](self: var PyList[T]; x: T)
• collections_abc: proc append[T](ms: MutableSequence[T]; x: T)
• pybytearray: proc append(mself: PyByteArray; val: int)

ArithmeticError:

• ops: object ArithmeticError

ascii:

• strbltins: proc ascii(us: PyStr): PyStr
• strbltins: proc ascii(us: string): PyStr
• strbltins: template ascii(c: char): PyStr
• strbltins: template ascii(a: untyped): PyStr

asHashSet:

• set_decl: proc asHashSet[H](self: SomePySet[H]): HashSet[H]
• set_decl: proc asHashSet[H](self: var SomePySet[H]): var HashSet[H]

as_integer_ratio:

• numTypes: template as_integer_ratio(self: NimInt): (NimInt, NimInt)

asSeq:

• list_decl: converter asSeq[T](self: PyList[T]): seq[T]
• list_decl: converter asSeq[T](self: var PyList[T]): var seq[T]

asVersion:

• version: template asVersion(v: tuple): string
• version: template asVersion(major, minor, patch: int): string

async:

• pydef: macro async(defsign, body): untyped

asyncImpl:

• pydef: proc asyncImpl(defsign, body: NimNode; parser: var PyFuncBodyProcesser; procType = nnkProcDef): NimNode

b:

• bytesprefix: proc b(c: char{lit}): PyBytes
• bytesprefix: proc b(s: static[string]{lit}): PyBytes

bin:

• strbltins: proc bin(a`gensym6: SomeInteger): PyStr

bit_length:

• numTypes: template bit_length(self: NimInt): NimInt

bool:

• pybool: proc bool[T](arg: T): PyBool

br:

• bytesprefix: proc br(s: string{lit}): PyBytes

Br:

• bytesprefix: template Br(s): PyBytes

BufferedIOBase:

• io: type BufferedIOBase

BufferedRandom:

• io: type BufferedRandom

BufferedReader:

• io: type BufferedReader

BufferedWriter:

• io: type BufferedWriter

bytearray:

• pybytearray: proc bytearray(): PyByteArray
• pybytearray: proc bytearray(o: BytesLike): PyByteArray
• pybytearray: proc bytearray(nbytes: int): PyByteArray
• pybytearray: proc bytearray(it: Iterable[char]): PyByteArray
• pybytearray: proc bytearray(it: Iterable[int]): PyByteArray
• pybytearray: proc bytearray(s: string): PyByteArray

byteLen:

• bytesimpl: proc byteLen(self: PyBytes): int
• strimpl: proc byteLen(self: PyStr): int

bytes:

• bytesimpl: proc bytes(): PyBytes
• bytesimpl: proc bytes(c: char): PyBytes
• bytesimpl: proc bytes(nLen: int): PyBytes
• bytesimpl: proc bytes(x: Iterable[char]): PyBytes
• bytesimpl: proc bytes(x: Iterable[int]): PyBytes
• bytesimpl: proc bytes(s: openArray[char]): PyBytes
• bytesimpl: proc bytes(s: string): PyBytes
• bytesimpl: proc bytes(self: PyBytes): PyBytes

BytesLike:

• pybytearray: type BytesLike

CanIOOpenT:

• io_abc: type CanIOOpenT

capitalize:

• bytesmeth: proc capitalize(a: PyBytes): PyBytes
• strmeth: proc capitalize(a: PyStr): PyStr

casefold:

• bytesmeth: template casefold(a: PyBytes): PyBytes
• strmeth: proc casefold(a: PyStr): PyStr

center:

• bytesmeth: proc center(a: PyBytes; width: int; fillchar = ' '): PyBytes
• bytesmeth: proc center(a: PyBytes; width: int; fillchar: PyBytes): PyBytes
• strmeth: proc center(a: PyStr; width: int; fillchar = ' '): PyStr
• strmeth: proc center(a: PyStr; width: int; fillchar: PyStr): PyStr
• meth: proc center[S](a: S; width: int; fillchar = ' '): S
• meth: proc center[S](a: S; width: int; fillchar: S = " "): S

chars:

• pybytearray: iterator chars(self: PyByteArray): char
• bytesimpl: iterator chars(self: PyBytes): char
• strimpl: iterator chars(self: PyStr): char

chr:

• strbltins: proc chr(a: SomeInteger): PyStr

class:

• class: macro class(obj, body: untyped): untyped

classImpl:

• class: proc classImpl(obj, body: NimNode): NimNode

clear:

• dict: proc clear(self: PyDict)
• list: proc clear(self: var PyList)
• set_decl: proc clear(self: var PySet): int
• collections_abc: proc clear(ms: MutableSequence)
• pybytearray: proc clear(mself: PyByteArray)

close:

• io: method close(self: IOBase)
• io: method close(self: RawIOBase)
• io: method close(self: TextIOWrapper)
• open_close: proc close(fd: int)

closerange:

• open_close: proc closerange(fd_low, fd_high: int)

Collection:

• collections_abc: type Collection

CompileBackend:

• backendMark: enum CompileBackend

complex:

• complex: proc complex[T: SomeFloat](re: T = 0.0; im: T = 0.0): PyComplex[T]
• complex: proc complex[T: SomeInteger](re: T = 0; im: T = 0): PyComplex[BiggestFloat]

conjugate:

• complex: proc conjugate[T](z: PyComplex[T]): PyComplex[T]
• numTypes: template conjugate(self: NimInt): NimInt

consumeDecorator:

• decorator: proc consumeDecorator(mparser; procDef: NimNode): NimNode

Container:

• collections_abc: type Container

contains:

• dict: proc contains[A, B](t: PyDict[A, B]; key: A): bool
• dict: proc contains[K, V](t: PyDictItemView[K, V]; x: (K, V)): bool
• dict: proc contains[T](t: PyDictKeyView[T]; x: T): bool
• dict: proc contains[T](t: PyDictValueView[T]; x: T): bool
• pyrange: proc contains[T](x: PyRange[T]; y: T): bool
• set_decl: proc contains[H](self: SomePySet[H]; x: H): bool
• collections_abc: proc contains[T](s: Container[T]; x: T): bool
• collections_abc: proc contains[K, V](m: Mapping[K, V]; k: K): bool
• bytesmeth: proc contains(a: PyBytes; o: int): bool
• bytesmeth: proc contains(a: PyBytes; o: PyBytes): bool
• strimpl: proc contains(s: PyStr; c: char): bool
• strimpl: proc contains(s: PyStr; c: PyStr): bool
• strimpl: proc contains(s: PyStr; c: string): bool
• frame: proc contains(mparser; ident: string): bool

copy:

• dict: proc copy[K, V](self: PyDict[K, V]): PyDict[K, V]
• set: template copy[H; S: SomePySet[H]](self): S
• pybytearray: proc copy(self: PyByteArray): PyByteArray

count:

• pyrange: proc count[T](r: PyRange[T]; x: T): int
• collections_abc: proc count[T](s: Sequence[T]; x: T): int
• bytesmeth: proc count(a: PyBytes; sub: int): int
• bytesmeth: proc count(a: PyBytes; sub: int; start: int): int
• bytesmeth: proc count(a: PyBytes; sub: int; start = 0; end: int): int
• bytesmeth: proc count(a: PyBytes; sub: PyBytes): int
• bytesmeth: proc count(a: PyBytes; sub: PyBytes; start: int): int
• bytesmeth: proc count(a: PyBytes; sub: PyBytes; start = 0; end: int): int
• strmeth: proc count(a: PyStr; sub: PyStr): int
• strmeth: proc count(a: PyStr; sub: PyStr; start: int): int
• strmeth: proc count(a: PyStr; sub: PyStr; start = 0; end: int): int
• meth: proc count[S](a: S; sub: S): int
• meth: proc count[S](a: S; sub: S; start: int): int
• meth: proc count[S](a: S; sub: S; start = 0; end: int): int

curdir:

• consts: let curdir

Decorator:

• frame: type Decorator

decorators:

• frame: proc decorators(mparser): var seq[Decorator]

def:

• pydef: macro def(signature, body): untyped

defAux:

• pydef: proc defAux(signature, body: NimNode; deftype = ident"untyped"; parser: var PyFuncBodyProcesser; procType = nnkTemplateDef; pragmas = emptyn): NimNode

DefEncoding:

• io: const DefEncoding

DefErrors:

• ncodec: const DefErrors

defImpl:

• pydef: proc defImpl(signature, body: NimNode; parser: var PyFuncBodyProcesser; pragmas = emptyn; deftype = ident"auto"; procType = nnkProcDef): NimNode

define:

• pydef: macro define(signature, body): untyped

DefNewLine:

• io: const DefNewLine

defpath:

• consts: const defpath

DefSplitCap:

• common: const DefSplitCap

del:

• pysugar: macro del(seqIdx: untyped)

delitem:

• dict: proc delitem[K, V](self: PyDict[K, V]; k: K)
• list: proc delitem(self: var PyList; idx: int)
• pybytearray: proc delitem(mself: PyByteArray; i: int)

DeprecationWarning:

• warnings: Warning.DeprecationWarning

devnull:

• consts: const devnull

dict:

• dict: macro dict(kwargs: varargs[untyped]): PyDict
• dict_decl: type dict

difference:

• set: proc difference[H](self: PyFrozenSet[H]; o: SomePySet[H]): PyFrozenSet[H]
• set: proc difference[H](self: PySet[H]; o: PyFrozenSet[H]): PyFrozenSet[H]
• set: proc difference[H](self, o: PySet[H]): PySet[H]
• set: proc difference[H; Self: SomePySet[H]; S](self: Self; s1: auto; s2: auto; x: varargs[S]): Self
• set: proc difference[H; Self: SomePySet[H]; S: not PySet[H]](self: Self; s: S): Self

difference_update:

• set: proc difference_update[H; I: Iterable[H]](self: var SomePySet[H]; i: I)

divmod:

• ops: proc divmod[T: SomeNumber](x, y: T): (T, T)

emptyPyDict:

• dict_decl: proc emptyPyDict[K, V](): PyDict[K, V]

EncErrors:

• ncodec: enum EncErrors

encoding:

• io: proc encoding(s: TextIOWrapper): PyStr

endsWith:

• bytesmeth: proc endsWith(a: PyBytes; suffix: char): bool
• bytesmeth: proc endsWith(a: PyBytes; suffix: int): bool
• bytesmeth: proc endsWith[Suf: PyBytes | tuple](a: PyBytes; suffix: Suf; start: int): bool
• bytesmeth: proc endsWith[Suf: PyBytes | tuple](a: PyBytes; suffix: Suf; start, end: int): bool
• bytesmeth: proc endsWith[Tup: tuple](a: PyBytes; suffix: Tup): bool
• strmeth: proc endsWith(a: char; suffix: PyStr): bool
• strmeth: proc endsWith(a: PyStr; suffix: char): bool
• strmeth: proc endsWith[Suf: PyStr | tuple](a: PyStr; suffix: Suf; start: int): bool
• strmeth: proc endsWith[Suf: PyStr | tuple](a: PyStr; suffix: Suf; start, end: int): bool
• strmeth: proc endsWith[Tup: tuple](a: PyStr; suffix: Tup): bool
• meth: proc endsWith[S; Suf: S | tuple](a: S; suffix: Suf; start: int): bool
• meth: proc endsWith[S; Suf: S | tuple](a: S; suffix: Suf; start, end: int): bool
• meth: proc endsWith[S; Tup: tuple](a: S; suffix: Tup): bool
• meth: template endsWith[S](a: char; suffix: S): bool
• meth: template endsWith[S](a: S; suffix: char): bool

enumerate:

• iters: proc enumerate[T](x: Iterable[T]; start = 0): Enumerate[T]
• iters: iterator enumerate[T](x: Iterable[T]; start = 0): (int, T)

errnoMsg:

• oserr: proc errnoMsg(errnoCode: cint): string

errors:

• io: proc errors(s: TextIOWrapper): PyStr

excl:

• set_decl: proc excl[H](self: var SomePySet[H]; x: H)

expandtabs:

• bytesmeth: proc expandtabs(a: PyBytes; tabsize = 8): PyBytes
• strmeth: proc expandtabs(a: PyStr; tabsize = 8): PyStr

expandtabsImpl:

• meth: template expandtabsImpl[S](a: S; tabsize: int; strByteLen: int; iter): string

extend:

• list: proc extend[T](self: var PyList[T]; ls: openArray[T])
• list: template extend[T](self: var PyList[T]; ls: Iterable[T])
• collections_abc: proc extend[T](ms: MutableSequence[T]; it: Iterable[T])
• pybytearray: proc extend(mself: PyByteArray; other: BytesLike)

extsep:

• consts: let extsep

f:

• fstring: template f(s: string{lit}): PyStr

False:

• pybool: const False

FileExistsError:

• oserr: object FileExistsError

FileIO:

• io: type FileIO

fileno:

• io: proc fileno(f: IOBase): int

FileNotFoundError:

• oserr: object FileNotFoundError

filter:

• iters: proc filter[T](comp: NoneType; iter: Iterable[T]): Filter[T]
• iters: proc filter[T](comp: proc (arg: T): bool; iter: Iterable[T]): Filter[T]
• iters: iterator filter[T](comp: NoneType; iter: Iterable[T]): T
• iters: iterator filter[T](comp: proc (arg: T): bool; iter: Iterable[T]): T

find:

• bytesmeth: proc find(a: PyBytes; b: int; start = 0; end = len(a)): int
• bytesmeth: proc find(a: PyBytes; b: PyBytes; start = 0; end = len(a)): int
• strmeth: proc find(a: PyStr; b: PyStr; start = 0; end = len(a)): int
• meth: proc find[S; T](a: S; b: T; start = 0): int
• meth: proc find[S; T](a: S; b: T; start = 0; end: int): int

find1:

• meth: proc find1[S; T](a: S; b: T; start = 0): int
• meth: proc find1[S; T](a: S; b: T; start = 0; end: int): int

float:

• numTypes: template float(a: PyStr | PyBytes): BiggestFloat
• numTypes: template float(a: bool): BiggestFloat
• numTypes: template float(f: SomeNumber): BiggestFloat

flush:

• io: proc flush(f: IOBase)

format:

• format: template format(s: PyStr; argKw: varargs[untyped]): PyStr
• format: template format[T](value: T; format_spec: PyStr = ""): PyStr
• formats: proc format(value: char; format_spec: string = ""): string
• formats: template format[T](value: T; format_spec: string = ""): string

fr:

• fstring: macro fr(pattern: string{lit}): PyStr

Fr:

• fstring: macro Fr(pattern: string{lit}): PyStr

from_bytes:

• numTypes: proc from_bytes(_: typedesc[NimInt]; bytes: PyBytes; byteorder: PyStr; signed = false): NimInt

fromhex:

• hex: proc fromhex(_: typedesc[PyBytes]; s: PyStr): PyBytes

frozenset:

• set: proc frozenset[H](s: HashSet[H]): PyFrozenSet[H]
• set: proc frozenset[H](it: Iterable[H]): PyFrozenSet[H]
• set: proc frozenset[H](arr: openArray[H]): PyFrozenSet[H]
• set: proc frozenset[H](s: SomePySet[H]): PyFrozenSet[H]
• set: proc frozenset[H](): PyFrozenSet[H]
• set_decl: type frozenset

fspath:

• io_abc: proc fspath(c: char): PyStr
• io_abc: proc fspath(s: string): PyStr
• bytesimpl: proc fspath(self: PyBytes): PyBytes
• strimpl: proc fspath(self: PyStr): PyStr

ftruncate:

• truncate: proc ftruncate(file: Positive; length: int64)

genIter:

• iterGen: macro genIter(def)

get:

• dict: proc get[K, V](self: PyDict[K, V]; key: K): V
• dict: proc get[K, V](self: PyDict[K, V]; key: K; default: V): V
• collections_abc: proc get[K, V](m: Mapping[K, V]; key: K): V
• collections_abc: proc get[K, V](m: Mapping[K, V]; key: K; default: V): V

getattr:

• attr: macro getattr(x; attr: static[string]): untyped
• attr: macro getattr(x; attr: static[string]; default): untyped

getChar:

• pybytearray: proc getChar(self: PyByteArray; i: Natural): char
• bytesimpl: proc getChar(self: PyBytes; i: Natural): char
• strimpl: proc getChar(self: PyStr; i: Natural): char

getCharPtr:

• pybytearray: proc getCharPtr(self: PyByteArray; i: Natural | Natural): ptr char
• bytesimpl: proc getCharPtr(self: PyBytes; i: Natural | BackwardsIndex): ptr char

getOrDefault:

• dict_decl: proc getOrDefault[A, B](t: PyDict[A, B]; key: A): B

getPtr:

• list_decl: proc getPtr[T](self: var PyList[T]; i: Natural | BackwardsIndex): ptr T

hasattr:

• attr: macro hasattr(x; attr: static[string]): bool

hasChar:

• bytesimpl: proc hasChar(a: PyBytes; o: char): bool

hash:

• pyhashes: proc hash(x: tuple): int
• pyhashes: proc hash(x: float): int
• pyhashes: proc hash(x: int): int
• pyhashes: proc hash(x: proc): int
• pyhashes: proc hash(x: PyBytes): int
• pyhashes: proc hash(x: PyComplex): int
• pyhashes: proc hash(x: PyDict): int
• pyhashes: proc hash(x: PyList): int
• pyhashes: proc hash(x: PySet): int
• pyhashes: proc hash(x: PyStr): int
• set_decl: proc hash[H](self: PyFrozenSet[H]): int

hex:

• hex: proc hex(self: PyBytes): PyStr
• hex: proc hex(self: PyBytes; sep: PyStr | PyBytes): PyStr
• hex: proc hex(self: PyBytes; sep: char | PyStr | PyBytes; bytes_per_sep: int): PyStr
• hex: proc hex(self: PyBytes; sep: char): PyStr
• strbltins: proc hex(a`gensym9: SomeInteger): PyStr

id:

• misc: template id(x): int

imag:

• complex: template imag[T](z`gensym0: PyComplex[T]): T

impExp:

• trans_imp: macro impExp(pre; mods: varargs[untyped])

incl:

• set_decl: proc incl[H](self: var SomePySet[H]; x: H)

index:

• pyrange: proc index[T](r: PyRange[T]; x: T): int
• collections_abc: proc index[T](s: Sequence[T]; x: T; start = 0; stop = -1): int
• bytesmeth: proc index(a: PyBytes; b: int; start = 0; end = len(a)): int
• bytesmeth: proc index(a: PyBytes; b: PyBytes; start = 0; end = len(a)): int
• strmeth: proc index(a, b: PyStr; start = 0; end = len(a)): int
• meth: proc index[S; T](a: S; b: T; start = 0): int
• meth: proc index[S; T](a: S; b: T; start = 0; end: int): int

index1:

• meth: proc index1[S; T](a: S; b: T; start = 0): int
• meth: proc index1[S; T](a: S; b: T; start = 0; end: int): int

indices:

• pyslice: proc indices(self: PySlice; length: int): (int, int, int)

initBufAsPy:

• io: proc initBufAsPy(nfile: var File; buf: int)

initNCodecInfo:

• ncodec: proc initNCodecInfo(encoding: string; errors = DefErrors): NCodecInfo

inner_incl:

• set_decl: proc inner_incl[H](self: var PyFrozenSet[H]; x: H)

input:

• input: proc input(prompt = str("")): PyStr

insert:

• list: proc insert[T](self: var PyList[T]; idx: int; x: T)
• pybytearray: proc insert(mself: PyByteArray; i: int; val: int)

int:

• numTypes: template int(a: PyStr | PyBytes): NimInt
• numTypes: template int(x: PyStr | PyBytes; base: int): NimInt
• numTypes: template int(a: bool): NimInt
• numTypes: template int(a: char): NimInt
• numTypes: template int(f: float): NimInt
• numTypes: template int(i: SomeInteger): NimInt

intersection:

• set: proc intersection[H](self: PyFrozenSet[H]; o: SomePySet[H]): PyFrozenSet[H]
• set: proc intersection[H](self: PySet[H]; o: PyFrozenSet[H]): PyFrozenSet[H]
• set: proc intersection[H](self, o: PySet[H]): PySet[H]
• set: proc intersection[H; Self: SomePySet[H]; S](self: Self; s1: auto; s2: auto; x: varargs[S]): Self
• set: proc intersection[H; Self: SomePySet[H]; S: not PySet[H]](self: Self; s: S): Self

intersection_update:

• set: proc intersection_update[H; I: Iterable[H]](self: var SomePySet[H]; i: I)

IOBase:

• io: type IOBase

iPosCeil:

• mathutils: proc iPosCeil[I: SomeInteger](x: float): I

IsADirectoryError:

• oserr: object IsADirectoryError

isalnum:

• meth: proc isalnum(c: char): bool
• meth: proc isalnum(s: string): bool

isalpha:

• bytesmeth: proc isalpha(a`gensym43: PyBytes): bool
• strmeth: proc isalpha(a: PyStr): bool
• meth: proc isalpha(c: char): bool
• meth: proc isalpha(s: string): bool

isascii:

• bytesmeth: proc isascii(a`gensym41: PyBytes): bool
• strmeth: proc isascii(a: PyStr): bool
• strmeth: proc isascii(a: Rune): bool
• meth: proc isascii(c: char): bool
• meth: proc isascii(s: string): bool

isatty:

• io: proc isatty(f: IOBase): bool
• isatty: proc isatty(fd: int): bool

isdigit:

• meth: proc isdigit(c: char): bool
• meth: proc isdigit(s: string): bool

isdisjoint:

• set: proc isdisjoint[H, S](self: SomePySet[H]; s: S): bool

isinstance:

• oopFuncs: template isinstance(obj, class_or_tuple): bool

islower:

• bytesmeth: proc islower(a: PyBytes): bool
• strmeth: proc islower(a: PyStr): bool

isNotFound:

• oserr: proc isNotFound(err: OSErrorCode): bool

isspace:

• bytesmeth: proc isspace(a`gensym42: PyBytes): bool

ISSPACE:

• common: proc ISSPACE(s: PyBytes; pos: int): bool
• common: proc ISSPACE(s: PyStr; pos: int): bool

isspace:

• strmeth: proc isspace(a: PyStr): bool
• meth: proc isspace(c: char): bool
• meth: proc isspace(s: string): bool

IsSpaceAt:

• common: type IsSpaceAt

issubclass:

• oopFuncs: template issubclass(obj, class_or_tuple): bool

issubset:

• set: proc issubset[H, S](self, o: SomePySet[H]; s: S): bool

issuperset:

• set: proc issuperset[H, S](self, o: SomePySet[H]; s: S): bool

istitle:

• bytesmeth: proc istitle(a: PyBytes): bool
• strmeth: proc istitle(a: PyStr): bool

istitleImpl:

• meth: template istitleImpl(a, isupper, islower: typed; iter, firstItemGetter)

isupper:

• bytesmeth: proc isupper(a: PyBytes): bool
• strmeth: proc isupper(a: PyStr): bool

items:

• dict: proc items[K, V](self: PyDict[K, V]): PyDictItemView[K, V]
• dict: iterator items[K, V](self: PyDict[K, V]): (K, V)
• dict: template items(view: SomePyDictView): untyped
• iter_next: iterator items[T](self: PyIterator[T]): T
• iters: template items(x: Enumerate): untyped
• iters: template items(x: Filter): untyped
• iters: template items(x: Map): untyped
• iters: template items(x: Reversed): untyped
• iters: template items(x: Zip): untyped
• list_decl: iterator items[T](self: PyList[T]): T
• pyrange: iterator items[T](rng: PyRange[T]): T
• set_decl: iterator items[H](self: SomePySet[H]): H
• collections_abc: iterator items[K, V](m: Mapping[K, V]): (K, V)
• pybytearray: iterator items(self: PyByteArray): int
• bytesimpl: iterator items(self: PyBytes): int
• strimpl: iterator items(self: PyStr): PyStr

iter:

• dict: proc iter[K, V](self: PyDict[K, V]): PyIterator[K]
• dict: iterator iter[K, V](self: PyDict[K, V]): K
• dict: template iter(view: SomePyDictView): untyped
• iter_next: proc iter[T](x: Iterable[T]): PyIterator[T]
• iter_next: proc iter[T](x: Iterator[T]): PyIterator[T]

Iterable:

• collections_abc: type Iterable

Iterator:

• collections_abc: type Iterator

join:

• bytesmeth: proc join[T](sep: PyBytes; a: openArray[T]): PyBytes
• strmeth: proc join[T](sep: PyStr; a: openArray[T]): PyStr
• meth: proc join[T](sep: char; a: openArray[T]): string
• meth: proc join[T, S](sep: S; a: openArray[T]): S

keys:

• dict: proc keys[K, V](self: PyDict[K, V]): PyDictKeyView[K]
• dict: iterator keys[K, V](self: PyDict[K, V]): K
• collections_abc: template keys[K, V](m: Mapping[K, V]): untyped

lambda:

• pysugar: template lambda(code: untyped): untyped

len:

• dict: proc len(self: PyDict): int
• dict: proc len(view: SomePyDictView): int
• list: template len(self: PyList): int
• pyrange: template len[T](rng: PyRange[T]): int
• set_decl: proc len(self: SomePySet): int
• pybytearray: proc len(self: PyByteArray): int
• bytesimpl: proc len(self: PyBytes): int
• strimpl: proc len(self: PyStr): int
• strimpl: proc len(c: char): int

linesep:

• consts: let linesep

list:

• list: proc list[T](iter: Iterable[T]): PyList[T]
• list: proc list[T](a: openArray[T]): PyList[T]
• list: proc list[T](x: seq[T]): PyList[T]
• list: proc list[T](): PyList[T]
• list_decl: type list

ljust:

• bytesmeth: proc ljust(a: PyBytes; width: int; fillchar = ' '): PyBytes
• bytesmeth: proc ljust(a: PyBytes; width: int; fillchar: PyBytes): PyBytes
• strmeth: proc ljust(a: PyStr; width: int; fillchar = ' '): PyStr
• strmeth: proc ljust(a: PyStr; width: int; fillchar: PyStr): PyStr
• meth: proc ljust[S](a: S; width: int; fillchar: S = " "): S
• meth: proc ljust(a: string; width: int; fillchar = ' '): string

LocaleEncoding:

• io: const LocaleEncoding

long:

• numTypes: template long(a: bool): int
• numTypes: template long(a: char): BiggestInt
• numTypes: template long(a: string): BiggestInt
• numTypes: template long[T: SomeNumber](a: T): BiggestInt

LookupError:

• lkuperr: object LookupError

lower:

• bytesmeth: proc lower(a: PyBytes): PyBytes
• strmeth: proc lower(a: PyStr): PyStr

lstrip:

• strip: proc lstrip(self: PyBytes): PyBytes
• strip: proc lstrip(self: PyBytes; chars: PyBytes): PyBytes
• strip: proc lstrip(self: PyStr): PyStr
• strip: proc lstrip(self: PyStr; chars: PyStr): PyStr

Major:

• version: const Major

makeIterable:

• iterGen: template makeIterable(Typ)

maketrans:

• translate: proc maketrans(_: typedesc[PyBytes]; frm, to: PyBytes): PyBytes
• translate: macro maketrans(_: typedesc[PyStr]; mapOrLit: untyped): TranslateTable
• translate: template maketrans(_: typedesc[PyStr]; frm, to): StrTypedTranslateTable
• translate: template maketrans(_: typedesc[PyStr]; frm, to, skip): TranslateTable

map:

• iters: proc map[T, R](function: proc (x: T): R; iterable: Iterable[T]): Map[T]
• iters: iterator map[T, R](function: proc (x: T): R; iterable: Iterable[T]): R

mapPathLike:

• io_abc: template mapPathLike[T](nexpr): T
• io_abc: template mapPathLike[T](s: PathLike[T]; nimProc): T

Mapping:

• collections_abc: type Mapping

max:

• pyrange: proc max[T](x: PyRange[T]): T

min:

• pyrange: proc min[T](x: PyRange[T]): T

Minor:

• version: const Minor

mitems:

• list_decl: iterator mitems[T](self: PyList[T]): var T

MutableSequence:

• collections_abc: type MutableSequence

name:

• consts: const name

NCodecInfo:

• ncodec: object NCodecInfo

newNoEncTextIO:

• io: proc newNoEncTextIO(file: File; name: string; newline = DefNewLine): NoEncTextIOWrapper

newPyAsgnFrame:

• frame: proc newPyAsgnFrame(): PyAsgnFrame

newPyAsgnRewriter:

• frame: proc newPyAsgnRewriter(): PyAsgnRewriter

newPyByteArray:

• pybytearray: proc newPyByteArray(): PyByteArray
• pybytearray: proc newPyByteArray(len: int): PyByteArray
• pybytearray: proc newPyByteArray(s: string): PyByteArray

newPyDictImpl:

• dict_decl: template newPyDictImpl[K, V](x: int): untyped
• dict_decl: template newPyDictImpl[K, V](x: varargs): untyped

newPyFrozenSet:

• set_decl: proc newPyFrozenSet[H](initialSize = defaultInitialSize): PyFrozenSet[H]
• set_decl: proc newPyFrozenSet[H](h: HashSet[H]): PyFrozenSet[H]

newPyIterator:

• iter_next: proc newPyIterator[T](it: iterator (): T): PyIterator[T]

newPyList:

• list_decl: proc newPyList[T](len = 0): PyList[T]
• list_decl: proc newPyList[T](a: openArray[T]): PyList[T]
• list_decl: proc newPyList[T](s: seq[T]): PyList[T]

newPyListOfCap:

• list_decl: proc newPyListOfCap[T](cap = 0): PyList[T]

newPySet:

• set_decl: proc newPySet[H](initialSize = defaultInitialSize): PySet[H]
• set_decl: proc newPySet[H](h: HashSet[H]): PySet[H]

next:

• iter_next: proc next[T](self: PyIterator[T]): T

nimArrayAsList:

• list: converter nimArrayAsList[T; I](arr: array[I, T]): PyList[T]

NimInt:

• numTypes: type NimInt

nimint:

• numTypes: template nimint(a): NimInt

noBackend:

• backendMark: template noBackend(backends: untyped; def)

noBackends:

• backendMark: template noBackends(backends: untyped; def)

noEmptySep:

• errHandle: template noEmptySep(sep)

NoEncTextIOBase:

• io: type NoEncTextIOBase

NoEncTextIOWrapper:

• io: type NoEncTextIOWrapper

noJsBackend:

• backendMark: template noJsBackend(def)

None:

• noneType: const None

NoneType:

• noneType: type NoneType

noNimsBackend:

• backendMark: template noNimsBackend(def)

nonlocalAdd:

• frame: proc nonlocalAdd(mparser; ident: string)

nonlocalContains:

• frame: proc nonlocalContains(mparser; ident: string): bool

norm_maxsplit:

• common: proc norm_maxsplit(maxsplit: int; str_len, sep_len: int): int
• common: template norm_maxsplit(maxsplit: int; str_len): int

NotADirectoryError:

• oserr: object NotADirectoryError

NotImplementedError:

• rterr: object NotImplementedError

noWeirdBackend:

• backendMark: template noWeirdBackend(def)

noWeirdTarget:

• oserr: template noWeirdTarget(def)

O_APPEND:

• consts: let O_APPEND

O_CLOEXEC:

• consts: let O_CLOEXEC

O_CREAT:

• consts: let O_CREAT

oct:

• strbltins: proc oct(a`gensym3: SomeInteger): PyStr

O_EXCL:

• consts: let O_EXCL

onceDeclInFrames:

• frame: proc onceDeclInFrames(ident: string; mparser): bool

open:

• io: template open(file: int; mode: static[string | char] = "r"; buffering: int = -1; encoding: string = DefEncoding; errors: string = DefErrors; newline: string | char = DefNewLine): untyped
• io: template open[S](file: PathLike[S]; mode: static[string | char] = "r"; buffering: int = -1; encoding: string = DefEncoding; errors: string = DefErrors; newline: string | char = DefNewLine): untyped
• open_close: proc open(path: PathLike; flags: int; mode = 0o000000000777; dir_fd = -1): int

ord:

• bytesbltins: proc ord(a: PyBytes): int
• strbltins: proc ord(a: PyStr): int

ord1:

• strbltins: proc ord1(a: PyStr): int

O_RDONLY:

• consts: let O_RDONLY

O_RDWR:

• consts: let O_RDWR

osErrorMsgWithPath:

• oserr: template osErrorMsgWithPath(fp: PathLike; err: OSErrorCode): string
• oserr: template osErrorMsgWithPath(fp: PathLike; err: OSErrorCode; osErrorMsgCb): string

O_TRUNC:

• consts: let O_TRUNC

O_WRONLY:

• consts: let O_WRONLY

pardir:

• consts: let pardir

parsePyBody:

• tonim: proc parsePyBody(mparser; body: NimNode): NimNode
• tonim: template parsePyBody(body: NimNode): NimNode

parsePyBodyWithDoc:

• tonim: proc parsePyBodyWithDoc(mparser; body: NimNode): NimNode
• tonim: proc parsePyBodyWithDoc(mparser; body: NimNode; docNode: var NimNode): NimNode

parsePyStmt:

• tonim: proc parsePyStmt(mparser; statement: NimNode): NimNode

parseSignature:

• funcSignature: proc parseSignature(signature: NimNode; deftype = ident"untyped"): tuple[ name: NimNode, params: seq[NimNode]]

partition:

• bytesmeth: proc partition(a: PyBytes; sep: PyBytes): tuple[before, sep, after: PyBytes]
• strmeth: proc partition(a: PyStr; sep: PyStr): tuple[before, sep, after: PyStr]
• meth: proc partition[S](a: S; sep: S): tuple[before, sep, after: S]

pass:

• pysugar: template pass(_)

Patch:

• version: const Patch

PathLike:

• io_abc: type PathLike

pathrepr:

• io_abc: proc pathrepr(p: PathLike[PyBytes]): string
• io_abc: proc pathrepr(p: PathLike[PyStr]): string

pathsAsOne:

• oserr: proc pathsAsOne[T](a, b: PathLike[T]; sep = " -> "): string

pathsep:

• consts: let pathsep

pop:

• dict: proc pop[K, V](self: PyDict[K, V]; key: K): V
• dict: proc pop[K, V](self: PyDict[K, V]; key: K; default: V): V
• list: proc pop[T](self: var PyList[T]): T
• list: proc pop[T](self: var PyList[T]; index: int): T
• set_decl: proc pop[H](self: var PySet[H]): H
• collections_abc: proc pop[T](ms: MutableSequence[T]; index = -1): T
• pybytearray: proc pop(mself: PyByteArray): int
• frame: proc pop(mparser)

popitem:

• dict: proc popitem[K, V](self: PyDict[K, V]): (K, V)

pow:

• mathfunc: proc pow(base, exp, modulo: float): int
• mathfunc: proc pow(base: int; exp: Natural): int
• modPow: proc pow(base, exp, modulo: int): int

PREPARE_CAP:

• common: template PREPARE_CAP(maxcount): int

print:

• print: macro print(data: varargs[untyped]): untyped

push:

• frame: proc push(mparser)

pushDecorator:

• decorator: proc pushDecorator(mparser; item: NimNode)

pyasciiImpl:

• asciiImpl: proc pyasciiImpl(us: string): string

PyAsgnFrame:

• frame: type PyAsgnFrame

PyAsgnRewriter:

• frame: object PyAsgnRewriter

PyBool:

• pybool: type PyBool

pybool:

• pybool: converter pybool(x: bool): PyBool
• pybool: converter pybool[T](x: T): PyBool

PyByteArray:

• pybytearray: type PyByteArray

PyBytes:

• bytesimpl: type PyBytes

pybytes:

• bytesimpl: template pybytes[T](x: T): PyBytes

PyComplex:

• complex: type PyComplex

pycomplex:

• complex: template pycomplex[T](z: Complex[T]): PyComplex[T]
• complex: template pycomplex[T](re: T; im = T(0)): PyComplex[T]

PyDict:

• dict_decl: type PyDict

PyDictItemView:

• dict: object PyDictItemView

PyDictKeyView:

• dict: object PyDictKeyView

PyDictValueView:

• dict: object PyDictValueView

PyDictView:

• dict: object PyDictView

pydiscard:

• set: proc pydiscard[H](self: var PySet[H]; ele: H)

pyformat:

• format: macro pyformat(s: static[string]; argKw: varargs[untyped]): string

pyformatImplAux:

• format: proc pyformatImplAux(s: string; args: seq[NimNode]; kw: Kw): NimNode

PyFrozenSet:

• set_decl: type PyFrozenSet

PyIterator:

• iter_next: type PyIterator

PyList:

• list_decl: type PyList

PyMajor:

• version: const PyMajor

PyMinor:

• version: const PyMinor

PyPatch:

• version: const PyPatch

PyRange:

• pyrange: type PyRange

PyReleaseLevel:

• version: const PyReleaseLevel

pyrepr:

• strbltins: proc pyrepr(s: StringLike): PyStr

pyreprbImpl:

• reprImpl: proc pyreprbImpl(s: string): string

pyreprImpl:

• reprImpl: proc pyreprImpl(s: string): string

PySerial:

• version: const PySerial

pyset:

• set: proc pyset[H](s: HashSet[H]): PySet[H]
• set: proc pyset[H](iterable: Iterable[H]): PySet[H]
• set: proc pyset[H](arr: openArray[H]): PySet[H]
• set: proc pyset[H](s: SomePySet[H]): PySet[H]
• set: proc pyset[H](): PySet[H]

PySet:

• set_decl: type PySet

pysetLit:

• set: macro pysetLit(lit): PySet

PySlice:

• pyslice: type PySlice

PySlice1:

• pyslice: type PySlice1

PyStr:

• strimpl: type PyStr

raiseErrno:

• oserr: proc raiseErrno(additionalInfo = "")

raiseErrnoWithPath:

• oserr: proc raiseErrnoWithPath[T](p: PathLike[T])

raiseExcWithPath:

• oserr: proc raiseExcWithPath(p: PathLike)
• oserr: proc raiseExcWithPath(p: PathLike; errCode: OSErrorCode)
• oserr: proc raiseExcWithPath(fp: PathLike; exc: typedesc; err: OSErrorCode)
• oserr: proc raiseExcWithPath(fp: PathLike; exc: typedesc; err: OSErrorCode; additionalInfo: string)

raiseExcWithPath2:

• oserr: proc raiseExcWithPath2(src, dst: PathLike)

raiseFileExistsError:

• oserr: proc raiseFileExistsError(fp: PathLike)

raiseFileNotFoundError:

• oserr: proc raiseFileNotFoundError(fp: PathLike)
• oserr: proc raiseFileNotFoundError(fp: PathLike; err: OSErrorCode)

raiseOsOrFileNotFoundError:

• io: proc raiseOsOrFileNotFoundError(file: int)
• io: proc raiseOsOrFileNotFoundError[T](file: PathLike[T])

range:

• pyrange: proc range[T: SomeInteger](start, stop, step: T): PyRange[T]
• pyrange: template range[T: SomeInteger](stop: T): PyRange[T]
• pyrange: template range[T: SomeInteger](start, stop: T): PyRange[T]

rangeLen:

• mathutils: proc rangeLen[I](start, stop, step: I): I

RawIOBase:

• io: type RawIOBase

rb:

• bytesprefix: template rb(s): PyBytes

Rb:

• bytesprefix: template Rb(s): PyBytes

read:

• io: proc read(self: NoEncTextIOWrapper): PyStr
• io: proc read(self: NoEncTextIOWrapper; size: int): PyStr
• io: proc read(self: RawIOBase): PyBytes
• io: proc read(self: RawIOBase; size: int): PyBytes
• io: proc read(self: TextIOWrapper): PyStr
• io: proc read(self: TextIOWrapper; size: int): PyStr

readline:

• io: proc readline(self: NoEncTextIOWrapper): PyStr
• io: proc readline(self: NoEncTextIOWrapper; size: int): PyStr
• io: proc readline(self: RawIOBase): PyBytes
• io: proc readline(self: RawIOBase; size: Natural): PyBytes
• io: proc readline(self: TextIOWrapper): PyStr
• io: proc readline(self: TextIOWrapper; size: Natural): PyStr

real:

• complex: template real[T](z`gensym1: PyComplex[T]): T

recReplaceSuperCall:

• class: proc recReplaceSuperCall(n: NimNode; defSupCls: NimNode; start = 0): NimNode

ReleaseLevel:

• version: const ReleaseLevel

remove:

• set: proc remove[H](self: var PySet[H]; ele: H)
• collections_abc: proc remove[T](ms: MutableSequence[T]; x: T)
• pybytearray: proc remove(mself: PyByteArray; val: int)

removeprefix:

• bytesmeth: proc removeprefix(a: PyBytes; suffix: PyBytes): PyBytes
• strmeth: proc removeprefix(a: PyStr; suffix: PyStr): PyStr
• meth: proc removeprefix[S](a: S; suffix: S): S

removesuffix:

• bytesmeth: proc removesuffix(a: PyBytes; suffix: PyBytes): PyBytes
• strmeth: proc removesuffix(a: PyStr; suffix: PyStr): PyStr
• meth: proc removesuffix[S](a: S; suffix: S): S

replace:

• bytesmeth: proc replace(a: PyBytes; sub, by: PyBytes | char): PyBytes
• bytesmeth: proc replace(a: PyBytes; sub, by: PyBytes | char; count: int): PyBytes
• strmeth: proc replace(a: PyStr; sub, by: PyStr | char): PyStr
• strmeth: proc replace(a: PyStr; sub, by: PyStr | char; count: int): PyStr
• meth: proc replace[S](a: S; sub, by: char): S
• meth: proc replace[S](a: S; sub, by: char; count: int): S
• meth: proc replace[S](a: S; sub, by: S): S
• meth: proc replace[S](a: S; sub, by: S; count: int): S
• replaceWithCount: proc replace(s: string; sub, by: char; count: Natural): string
• replaceWithCount: proc replace(s: string; sub, by: string; count: Natural): string

repr:

• dict: template repr(self: PyDict): string
• dict: template repr(view`gensym3: PyDictItemView): string
• dict: template repr(view`gensym1: PyDictKeyView): string
• dict: template repr(view`gensym2: PyDictValueView): string
• list: proc repr(ls: PyList[char]): string
• list: template repr[T](ls: PyList[T]): string
• list_decl: proc repr[T: set | string | openArray](self: PyList[T]): string
• pyrange: proc repr[T](rng: PyRange[T]): string
• pyslice: proc repr(self: PySlice): string
• set_decl: proc repr(self: PyFrozenSet): string
• set_decl: proc repr(self: PySet): string
• pybool: proc repr(self: PyBool): string
• bytesbltins: proc repr(x: PyBytes): string
• strbltins: proc repr(x: PyStr): string
• translate: proc repr(table: TranslateTable): string

reverse:

• list: proc reverse(self: var PyList)
• collections_abc: proc reverse(ms: MutableSequence)
• pybytearray: proc reverse(mself: PyByteArray)

reversed:

• iters: proc reversed[T](x: Sequence[T]): Reversed[T]
• iters: iterator reversed[T](x: Sequence[T]): T
• bytesbltins: proc reversed(s: PyBytes): PyBytes
• strbltins: proc reversed(s: PyStr): PyStr

rewriteRaise:

• pyraise: proc rewriteRaise(rStmt: NimNode): NimNode

rf:

• fstring: macro rf(pattern: string{lit}): PyStr

Rf:

• fstring: macro Rf(pattern: string{lit}): PyStr

rfind:

• bytesmeth: proc rfind(a: PyBytes; b: int; start = 0; end = len(a)): int
• bytesmeth: proc rfind(a: PyBytes; b: PyBytes; start = 0; end = len(a)): int
• strmeth: proc rfind(a: PyStr; b: PyStr; start = 0; end = len(a)): int
• meth: proc rfind[S; T](a: S; b: T; start = 0): int
• meth: proc rfind[S; T](a: S; b: T; start = 0; end: int): int

rfind1:

• meth: proc rfind1[S; T](a: S; b: T; start = 0): int
• meth: proc rfind1[S; T](a: S; b: T; start = 0; end: int): int

rindex:

• bytesmeth: proc rindex(a: PyBytes; b: int; start = 0; end = len(a)): int
• bytesmeth: proc rindex(a: PyBytes; b: PyBytes; start = 0; end = len(a)): int
• strmeth: proc rindex(a, b: PyStr; start = 0; end = len(a)): int
• meth: proc rindex[S; T](a: S; b: T; start = 0): int
• meth: proc rindex[S; T](a: S; b: T; start = 0; end: int): int

rindex1:

• meth: proc rindex1[S; T](a: S; b: T; start = 0): int
• meth: proc rindex1[S; T](a: S; b: T; start = 0; end: int): int

rjust:

• bytesmeth: proc rjust(a: PyBytes; width: int; fillchar = ' '): PyBytes
• bytesmeth: proc rjust(a: PyBytes; width: int; fillchar: PyBytes): PyBytes
• strmeth: proc rjust(a: PyStr; width: int; fillchar = ' '): PyStr
• strmeth: proc rjust(a: PyStr; width: int; fillchar: PyStr): PyStr
• meth: proc rjust[S](a: S; width: int; fillchar: S = " "): S
• meth: proc rjust(a: string; width: int; fillchar = ' '): string

rpartition:

• bytesmeth: proc rpartition(a: PyBytes; sep: PyBytes): tuple[before, sep, after: PyBytes]
• strmeth: proc rpartition(a: PyStr; sep: PyStr): tuple[before, sep, after: PyStr]
• meth: proc rpartition[S](a: S; sep: S): tuple[before, sep, after: S]

rsplit:

• rsplit: proc rsplit(a: PyBytes; sep: PyBytes | char; maxsplit = -1): PyList[PyBytes]
• rsplit: proc rsplit(a: PyBytes; sep = None; maxsplit = -1): PyList[PyBytes]
• rsplit: iterator rsplit(a: PyBytes; sep = None; maxsplit = -1): PyBytes
• rsplit: proc rsplit(a: PyStr; sep = None; maxsplit = -1): PyList[PyStr]
• rsplit: proc rsplit(a: PyStr; sep: StringLike; maxsplit = -1): PyList[PyStr]
• rsplit: iterator rsplit(a: PyStr; sep = None; maxsplit = -1): PyStr

rsplit_whitespace:

• rsplit_whitespace: proc rsplit_whitespace(pystr: PyBytes; maxsplit = -1): PyList[PyBytes]
• rsplit_whitespace: proc rsplit_whitespace(pystr: PyStr; maxsplit = -1): PyList[PyStr]
• rsplit_whitespace: proc rsplit_whitespace[S](pystr: S; maxsplit = -1): PyList[S]

rstrip:

• strip: proc rstrip(self: PyBytes): PyBytes
• strip: proc rstrip(self: PyBytes; chars: PyBytes): PyBytes
• strip: proc rstrip(self: PyStr): PyStr
• strip: proc rstrip(self: PyStr; chars: PyStr): PyStr

runeAtPos:

• strimpl: proc runeAtPos(self: PyStr; pos: int): Rune

runeLenAt:

• strimpl: proc runeLenAt(self: PyStr; i: Natural): int

runes:

• strimpl: iterator runes(self: PyStr): Rune

RuntimeError:

• rterr: object RuntimeError

RuntimeWarning:

• warnings: Warning.RuntimeWarning

seek:

• io: method seek(f: IOBase; cookie: int64; whence = SEEK_SET): int64
• io: method seek(self: TextIOWrapper; cookie: int64; whence = SEEK_SET): int64

SEEK_CUR:

• io: const SEEK_CUR

SEEK_END:

• io: const SEEK_END

SEEK_SET:

• io: const SEEK_SET

sep:

• consts: let sep

Sequence:

• collections_abc: type Sequence

Serial:

• version: const Serial

set:

• set: proc set[H](s: HashSet[H]): PySet[H]
• set: proc set[H](iterable: Iterable[H]): PySet[H]
• set: proc set[H](arr: openArray[H]): PySet[H]
• set: proc set[H](s: SomePySet[H]): PySet[H]
• set: proc set[H](): PySet[H]
• set_decl: type set

setattr:

• attr: macro setattr(x; attr: static[string]; val)

setdefault:

• dict: proc setdefault[K, V](self: PyDict[K, V]; key: K; default = V.default)

setLen:

• list_decl: proc setLen(self: PyList; len: Natural)

Sized:

• collections_abc: type Sized

slice:

• pyslice: proc slice(stop: int): PySlice1
• pyslice: proc slice(start, stop: int): PySlice1
• pyslice: proc slice(start, stop: int; step: int): PySlice

SomePyDictView:

• dict: type SomePyDictView

SomePySet:

• set_decl: type SomePySet

SomeSet:

• set: type SomeSet

SomeSinglePyDictView:

• dict: type SomeSinglePyDictView

sort:

• list: proc sort[T](self: var PyList[T]; reverse = false)
• list: proc sort[T, K](self: var PyList[T]; key: proc (x: T): K; reverse = false)

sorted:

• list: proc sorted[T, K](x: not Sequence[T] and Iterable[T]; key: proc (x: T): K; reverse = false): PyList[T]
• list: proc sorted[T](self: PyList[T]; reverse = false): PyList[T]
• list: proc sorted[T, K](x: Sequence[T]; key: proc (x: T): K; reverse = false): PyList[T]

split:

• split: proc split(a: PyBytes; sep: PyBytes | char; maxsplit = -1): PyList[PyBytes]
• split: proc split(a: PyBytes; sep = None; maxsplit = -1): PyList[PyBytes]
• split: iterator split(a: PyBytes; sep: PyBytes | char; maxsplit = -1): PyBytes
• split: iterator split(a: PyBytes; sep = None; maxsplit = -1): PyBytes
• split: proc split(a: PyStr; sep = None; maxsplit = -1): PyList[PyStr]
• split: proc split(a: PyStr; sep: StringLike; maxsplit = -1): PyList[PyStr]
• split: iterator split(a: PyStr; sep = None; maxsplit = -1): PyStr
• split: iterator split(a: PyStr; sep: StringLike; maxsplit = -1): PyStr

splitlines:

• split: proc splitlines(self: PyBytes; keepends = false): PyList[PyBytes]
• splitlinesIter: iterator splitlines(self: PyBytes; keepends = false): PyBytes
• split: proc splitlines(self: PyStr; keepends = false): PyList[PyStr]
• splitlinesIter: iterator splitlines(self: PyStr; keepends = false): PyStr
• splitlinesIter: iterator splitlines[S](self: S; keepends = false): S

split_whitespace:

• split_whitespace: proc split_whitespace(pystr: PyBytes; maxsplit = -1): PyList[PyBytes]
• split_whitespace: iterator split_whitespace(pystr: PyBytes; maxsplit = -1): PyBytes
• split_whitespace: proc split_whitespace(pystr: PyStr; maxsplit = -1): PyList[PyStr]
• split_whitespace: iterator split_whitespace(pystr: PyStr; maxsplit = -1): PyStr
• split_whitespace: proc split_whitespace[S](pystr: S; maxsplit = -1): PyList[S]
• split_whitespace: iterator split_whitespace[S](pystr: S; maxsplit = -1): S

startsWith:

• bytesmeth: proc startsWith(a: PyBytes; suffix: char): bool
• bytesmeth: proc startsWith(a: PyBytes; suffix: int): bool
• bytesmeth: proc startsWith[Suf: PyBytes | tuple](a: PyBytes; suffix: Suf; start: int): bool
• bytesmeth: proc startsWith[Suf: PyBytes | tuple](a: PyBytes; suffix: Suf; start, end: int): bool
• bytesmeth: proc startsWith[Tup: tuple](a: PyBytes; suffix: Tup): bool
• strmeth: proc startsWith(a: char; suffix: PyStr): bool
• strmeth: proc startsWith(a: PyStr; suffix: char): bool
• strmeth: proc startsWith[Suf: PyStr | tuple](a: PyStr; suffix: Suf; start: int): bool
• strmeth: proc startsWith[Suf: PyStr | tuple](a: PyStr; suffix: Suf; start, end: int): bool
• strmeth: proc startsWith[Tup: tuple](a: PyStr; suffix: Tup): bool
• meth: proc startsWith[S; Suf: S | tuple](a: S; suffix: Suf; start: int): bool
• meth: proc startsWith[S; Suf: S | tuple](a: S; suffix: Suf; start, end: int): bool
• meth: proc startsWith[S; Tup: tuple](a: S; suffix: Tup): bool
• meth: template startsWith[S](a: char; suffix: S): bool
• meth: template startsWith[S](a: S; suffix: char): bool

StopIteration:

• iter_next: object StopIteration

str:

• strimpl: proc str(c: char): PyStr
• strimpl: proc str(self: PyStr): PyStr
• strimpl: proc str(a: Rune): PyStr
• strimpl: proc str(object = ""): PyStr
• strimpl: template str[O: object](o: O): PyStr
• strimpl: template str[T](a: T): PyStr

STRINGLIB_MUTABLE:

• common: const STRINGLIB_MUTABLE

StringLike:

• strimpl: type StringLike

strip:

• strip: proc strip(self: PyBytes): PyBytes
• strip: proc strip(self: PyBytes; chars: PyBytes): PyBytes
• strip: proc strip(self: PyStr): PyStr
• strip: proc strip(self: PyStr; chars: PyStr): PyStr

StrTypedTranslateTable:

• translate: type StrTypedTranslateTable

substr:

• bytesimpl: proc substr(self: PyBytes; start: int): PyBytes
• bytesimpl: proc substr(self: PyBytes; start, last: int): PyBytes
• strimpl: proc substr(self: PyStr; start, last: int): PyStr

suf--:

• common: proc suf--(i: var int): int

symmetric_difference:

• set: proc symmetric_difference[H](self: PyFrozenSet[H]; o: SomePySet[H]): PyFrozenSet[H]
• set: proc symmetric_difference[H](self: PySet[H]; o: PyFrozenSet[H]): PyFrozenSet[H]
• set: proc symmetric_difference[H](self, o: PySet[H]): PySet[H]
• set: proc symmetric_difference[H; Self: SomePySet[H]; S](self: Self; s1: auto; s2: auto; x: varargs[S]): Self
• set: proc symmetric_difference[H; Self: SomePySet[H]; S: not PySet[H]](self: Self; s: S): Self

SystemExit:

• simperr: object SystemExit

tell:

• io: proc tell(f: IOBase): int64

TextIOWrapper:

• io: type TextIOWrapper

timeit:

• pylib: template timeit(repetitions: int; statements: untyped): untyped
• timeit: template timeit(stmt; setup; number = 1000000): float
• timeit: template timeit(stmt; number = 1000000): float
• timeit: template timeit(number = 1000000): float
• timeit: template timeit(repetitions: int; statements: untyped)

title:

• bytesmeth: proc title(a: PyBytes): PyBytes
• strmeth: proc title(a: PyStr): PyStr

toBool:

• pybool: template toBool[T](arg: T): bool

to_bytes:

• numTypes: proc to_bytes(self: NimInt; length: int; byteorder: PyStr; signed = false): PyBytes

tonim:

• tonim: macro tonim(body): untyped

toNimBool:

• pybool: converter toNimBool(self: PyBool): bool

toNimComplex:

• complex: template toNimComplex[T](z: PyComplex[T]): Complex[T]

toNimSlice:

• pyslice: converter toNimSlice(s: PySlice1): Slice[int]

toNimStr:

• strimpl: proc toNimStr(self: PyStr): string

toNimString:

• pybytearray: template toNimString(self: PyByteArray): string
• bytesimpl: converter toNimString(self: PyBytes): string
• strimpl: converter toNimString(self: PyStr): string

toNimTable:

• dict_decl: proc toNimTable[K, V](self: PyDict[K, V]): var OrderedTable[K, V]

toPyBytes:

• pybytearray: converter toPyBytes(self: PyByteArray): PyBytes

toPyDict:

• dict: proc toPyDict[K, V](x: not openArray[(K, V)] and Iterable[(K, V)]): PyDict[K, V]
• dict: proc toPyDict[K, V](x: openArray[(K, V)]): PyDict[K, V]

toPyStr:

• strimpl: converter toPyStr(s: char): PyStr
• strimpl: converter toPyStr(s: Rune): PyStr
• strimpl: converter toPyStr(s: string): PyStr

translate:

• translate: proc translate(self: PyBytes; table: NoneType; delete: PyBytes): PyBytes
• translate: proc translate(self, table: PyBytes): PyBytes
• translate: proc translate(self, table, delete: PyBytes): PyBytes
• translate: proc translate(s: PyStr; table: StrTypedTranslateTable): PyStr
• translate: proc translate(s: PyStr; table: TranslateTable): PyStr
• translate: proc translate(s: PyStr; table: TranslateTableABC): PyStr
• translate: proc translate[K: TranslateValType](s: PyStr; table: TypedTranslateTableABC[K]): PyStr

TranslateAction:

• translate: enum TranslateAction

translateEscape:

• translateEscape: proc translateEscape(pattern: string): string

translateEscapeWithErr:

• translateEscape: macro translateEscapeWithErr(pattern: string): string

TranslateTable:

• translate: type TranslateTable

TranslateTableABC:

• translate: type TranslateTableABC

TranslateTableVal:

• translate: object TranslateTableVal

TranslateValType:

• translate: type TranslateValType

True:

• pybool: const True

truncate:

• io: proc truncate(self: IOBase): int
• io: proc truncate(self: IOBase; size: int64): int64
• truncate: proc truncate(file: CanIOOpenT; length: Natural)

tryHandleDecorator:

• decorator: proc tryHandleDecorator(mparser; statement: NimNode): bool

tryOsOp:

• oserr: template tryOsOp(p: PathLike; body)

TypedTranslateTableABC:

• translate: type TypedTranslateTableABC

TypeError:

• simperr: object TypeError

u:

• strprefix: proc u(s: static[string]{lit}): PyStr
• strprefix: proc u(a: char{lit}): PyStr

unicodeSpaces:

• consts: const unicodeSpaces

union:

• set: proc union[H](self: PyFrozenSet[H]; o: SomePySet[H]): PyFrozenSet[H]
• set: proc union[H](self: PySet[H]; o: PyFrozenSet[H]): PyFrozenSet[H]
• set: proc union[H](self, o: PySet[H]): PySet[H]
• set: proc union[H; Self: SomePySet[H]; S](self: Self; s1: auto; s2: auto; x: varargs[S]): Self
• set: proc union[H; Self: SomePySet[H]; S: not PySet[H]](self: Self; s: S): Self

unpack:

• unpack: macro unpack(data: untyped; values: varargs[untyped]): untyped

unpackImpl:

• unpack: proc unpackImpl(data: NimNode; symbols: NimNode): NimNode

unpackImplRec:

• unpack: template unpackImplRec(data: NimNode; symbols: NimNode; res: var NimNode; receiver)

unpackWithLenImpl:

• unpack: proc unpackWithLenImpl(data: NimNode; len2unpack: Positive): NimNode

UnsupportedOperation:

• io: object UnsupportedOperation

update:

• dict: macro update(self: PyDict; kws: varargs[untyped])
• set: proc update[H; I: Iterable[H]](self: var SomePySet[H]; i: I)

upper:

• bytesmeth: proc upper(a: PyBytes): PyBytes
• strmeth: proc upper(a: PyStr): PyStr

UserWarning:

• warnings: Warning.UserWarning

values:

• dict: proc values[K, V](self: PyDict[K, V]): PyDictValueView[V]
• dict: iterator values[K, V](self: PyDict[K, V]): V
• collections_abc: iterator values[K, V](m: Mapping[K, V]): V

Version:

• version: const Version

warn:

• warnings: template warn(message: string; category: Warning = UserWarning; stacklevel = 1)

Warning:

• warnings: enum Warning

with:

• pywith: macro with(args: varargs[untyped]): untyped

write:

• io: proc write(self: NoEncTextIOWrapper; s: PyStr): int
• io: proc write(self: RawIOBase; s: PyBytes): int
• io: proc write(self: TextIOWrapper; s: PyStr): int

ZeroDivisionError:

• ops: object ZeroDivisionError

zfill:

• bytesmeth: proc zfill(a: PyBytes; width: int): PyBytes
• strmeth: proc zfill(a: PyStr; width: int): PyStr
• meth: proc zfill(c: char; width: int): string
• meth: proc zfill(a: string; width: int): string

zip:

• iters: proc zip[A, B](it1: Iterable[A]; it2: Iterable[B]; strict: static[bool] = false): Zip[ A]
• iters: iterator zip[A, B](it1: Iterable[A]; it2: Iterable[B]; strict: static[bool] = false): (A, B)