Index

Modules: ../Python/envutils, ../Python/fileutils, ../Python/force_ascii_utils, ../Python/internal/pycore_fileutils, ../Python/localeutils, ../Python/pylifecycle/signal, ../Python/pylifecycle/signal/c_syms, ../Python/pylifecycle/signal/chk_util, ../Python/pylifecycle/signal/handler_types, ../Python/pytime/deadline, ../Python/pytime/exc_util, ../Python/pytime/monotonic, ../Python/pytime/ops, ../Python/pytime/pytimeAsTimeval, ../Python/pytime/pytimeFromSeconds, ../Python/pytime/rounds, ../Python/pytime/time_t_decl, ../Python/pytime/types, ../Python/pytime/units, ../Python/unicodeobject/char_decl, ../Python/unicodeobject/codecs, ../Python/unicodeobject/cstring_ptr_op, ../Python/unicodeobject/locale_codec, ../Python/unicodeobject/ptr_op, ../Python/unicodeobject/ptr_types, ../Python/unicodeobject/utf8_codec, ../Python/unicodeobject/wchar_utils, ../Python/wchar_t, ../builtins/asciiImpl, ../builtins/dict, ../builtins/dict_decl, ../builtins/iter_next, ../builtins/iters, ../builtins/iters/macroutils, ../builtins/iters/mapMacro, ../builtins/iters/zipMacro, ../builtins/list, ../builtins/list_decl, ../builtins/private/mathutils, ../builtins/private/strIter, ../builtins/pyrange, ../builtins/pyslice, ../builtins/reprImpl, ../builtins/set, ../builtins/set_decl, ../collections_abc, ../collections_abc/asyncs, ../collections_abc/collections, ../collections_abc/generators, ../collections_abc/iters, ../collections_abc/private/templ, ../io_abc, ../mutSeqSliceOp, ../nimpatch/abs, ../nimpatch/nansign, ../nimpatch/newUninit, ../nimpatch/utils, ../noneType, ../private/backendMark, ../private/encoding_norm, ../private/inspect_cleandoc, ../private/iph_utils, ../private/iterGen, ../private/platform_utils, ../private/trans_imp, ../pybool, ../pybytes/bytesbltins, ../pybytes/bytesimpl, ../pyconfig/bootstrap_hash, ../pyconfig/floats, ../pyconfig/os_consts, ../pyconfig/pycore/pymath, ../pyconfig/pycore/pymath/short_float_repr, ../pyconfig/resource, ../pyconfig/signal, ../pyconfig/util, ../pyconfig/ver, ../pyerrors, ../pyerrors/aritherr, ../pyerrors/errno, ../pyerrors/lkuperr, ../pyerrors/oserr, ../pyerrors/oserr/errmap, ../pyerrors/oserr/init, ../pyerrors/oserr/oserror_decl, ../pyerrors/oserr/oserror_new, ../pyerrors/oserr/oserror_str, ../pyerrors/oserr/types, ../pyerrors/rterr, ../pyerrors/signals, ../pyerrors/simperr, ../pyerrors/unicode_err, ../pystring, ../pystring/consts, ../pystring/format, ../pystring/fstring, ../pystring/split/common, ../pystring/split/reimporter, ../pystring/split/rsplit, ../pystring/split/rsplit_whitespace, ../pystring/split/split, ../pystring/split/split_whitespace, ../pystring/split/splitlinesIter, ../pystring/strbltins, ../pystring/strimpl, ../pystring/strip, ../pystring/strmeth, ../pystring/strops, ../pystring/strprefix, ../pystring/translate, ../stringlib/errHandle, ../stringlib/format, ../stringlib/formats, ../stringlib/meth, ../stringlib/replaceWithCount, ../stringlib/split/common, ../stringlib/split/reimporter, ../stringlib/split/rsplit_whitespace, ../stringlib/split/split_whitespace, ../stringlib/split/splitlinesIter, ../translateEscape, ../version, ../versionInfo, collections/abc, datetime, datetime_impl/consts, datetime_impl/datetime_impl, datetime_impl/datetime_impl/decl, datetime_impl/datetime_impl/inner_decl, datetime_impl/datetime_impl/meth, datetime_impl/datetime_impl/meth/aszone, datetime_impl/datetime_impl/meth/calendar_utils, datetime_impl/datetime_impl/meth/consts, datetime_impl/datetime_impl/meth/errno_decl, datetime_impl/datetime_impl/meth/format_utcoffset, datetime_impl/datetime_impl/meth/formats, datetime_impl/datetime_impl/meth/fromisoformat, datetime_impl/datetime_impl/meth/getter, datetime_impl/datetime_impl/meth/getter_of_date, datetime_impl/datetime_impl/meth/getter_requires_op, datetime_impl/datetime_impl/meth/hashImpl, datetime_impl/datetime_impl/meth/importer, datetime_impl/datetime_impl/meth/init, datetime_impl/datetime_impl/meth/inner_consts, datetime_impl/datetime_impl/meth/isoformat, datetime_impl/datetime_impl/meth/op, datetime_impl/datetime_impl/meth/platform_utils, datetime_impl/datetime_impl/meth/pytime, datetime_impl/datetime_impl/meth/require_time_module, datetime_impl/datetime_impl/meth/state_consts, datetime_impl/datetime_impl/meth/statics, datetime_impl/datetime_impl/meth/struct_tm_decl, datetime_impl/datetime_impl/meth/struct_tm_helper, datetime_impl/datetime_impl/meth/struct_tm_meth, datetime_impl/datetime_impl/meth/time_t_decl, datetime_impl/datetime_impl/meth/time_utils, datetime_impl/datetime_impl/meth/to_seconds_utils, datetime_impl/datetime_impl/meth/zonename_utils, datetime_impl/delta_chk, datetime_impl/mathutils, datetime_impl/obj_utils, datetime_impl/pyerr, datetime_impl/timedelta_impl, datetime_impl/timedelta_impl/decl, datetime_impl/timedelta_impl/getter, datetime_impl/timedelta_impl/meth, datetime_impl/timezone_impl, datetime_impl/timezone_impl/decl, datetime_impl/timezone_impl/meth_by_datetime, datetime_impl/timezone_impl/meth_by_datetime_getter, datetime_impl/timezone_impl/meth_else, datetime_impl/types, enum_impl/enumType, enum_impl/intEnum, errno, errno_impl/errnoConsts, errno_impl/errnoUtils, errno_impl/private/clike, errno_impl/private/errnos, errno_impl/private/errorcodeInit, errno_impl/private/exportUtils, errno_impl/private/loopErrno, errno_impl/private/singleton_errno, inspect, inspect_impl/isX, inspect_impl/members, inspect_impl/modulename, inspect_impl/sourcegetters, io, math, math_impl/cbrt, math_impl/comptime/cbrt, math_impl/comptime/common, math_impl/comptime/expm1, math_impl/comptime/log1p, math_impl/constsUtils, math_impl/err, math_impl/errnoUtils, math_impl/expm1_log1p, math_impl/frexp, math_impl/gammaXRange, math_impl/inWordUtils/assertIsLittleEndian, math_impl/inWordUtils/consts, math_impl/inWordUtils/float_view, math_impl/inWordUtils/fromWords, math_impl/inWordUtils/indices, math_impl/inWordUtils/toWords, math_impl/isX, math_impl/ldexp, math_impl/nextafter_step, math_impl/nextafter_ulp, math_impl/patch/consts, math_impl/patch/fma, math_impl/patch/gamma, math_impl/patch/inWordUtilsMapper, math_impl/patch/ldexp_frexp/assertIsInfinite, math_impl/patch/ldexp_frexp/exponent, math_impl/patch/ldexp_frexp/frexp, math_impl/patch/ldexp_frexp/ldexp, math_impl/patch/ldexp_frexp/normalize, math_impl/patch/lgamma, math_impl/patch/nextafter, math_impl/patch/nextafter_step, math_impl/patch/sinpi, math_impl/patch/trunc, math_impl/platformUtils, math_impl/polevl, math_impl/vec_op, math_impl/vec_op/dist, math_impl/vec_op/niter_types, math_impl/vec_op/private/dl_ops, math_impl/vec_op/sumprod, n_bisect, n_datetime, n_errno, n_inspect, n_itertools, n_math, n_os, n_pathlib, n_random, n_signal, n_stat, n_string, n_sys, n_time, ncodec, os, os_impl/common, os_impl/consts, os_impl/inheritable, os_impl/listcommon, os_impl/listdirx, os_impl/path, os_impl/posix_like, os_impl/posix_like/errnoHandle, os_impl/posix_like/fdopen, os_impl/posix_like/get_id, os_impl/posix_like/isatty, os_impl/posix_like/links, os_impl/posix_like/lseek, os_impl/posix_like/mkrmdir, os_impl/posix_like/mkrmdirImpl, os_impl/posix_like/open_close, os_impl/posix_like/rename, os_impl/posix_like/scandirImpl, os_impl/posix_like/seek_consts, os_impl/posix_like/stat, os_impl/posix_like/truncate, os_impl/posix_like/unlink, os_impl/posix_like/unlinkImpl, os_impl/posix_like/utime, os_impl/private/defined_macros, os_impl/private/iph_utils, os_impl/private/platform_utils, os_impl/randoms, os_impl/subp, os_impl/term, os_impl/touch, os_impl/util/handle_signal, os_impl/utils, os_impl/waits, os_impl/walkImpl, pathlib, pathlib_impl/init, pathlib_impl/meth, pathlib_impl/os_meth, pathlib_impl/segments, pathlib_impl/types, private/platformInfo, private/platformUtils, random, random_impl/gstate, random_impl/justLessThanOneConst, random_impl/macroutils, random_impl/proc_dispatched, random_impl/proc_others, random_impl/types, resource, resource_impl/consts, resource_impl/csyms, resource_impl/funcs, resource_impl/types, signal, signal_impl/abc_set, signal_impl/c_api, signal_impl/c_py_handler_cvt, signal_impl/chk_util, signal_impl/enums, signal_impl/enums_decl, signal_impl/errutil, signal_impl/frames, signal_impl/pyatomic, signal_impl/pylifecycle, signal_impl/pynsig, signal_impl/siginfo_decl, signal_impl/signal_util, signal_impl/signals, signal_impl/sigsetCvt, signal_impl/sigset_to_set, signal_impl/state, signal_impl/unixs, signal_impl/valid_signals_impl, stat, stat_impl/consts, stat_impl/defines, stat_impl/isX, stat_impl/isXImpl, stat_impl/strrepr, stat_impl/types, string, string_impl/capwordsImpl, string_impl/consts, string_impl/n_chainmap, string_impl/substituteImpl, string_impl/templateImpl, string_impl/template_decl, sys, sys_impl/exits, sys_impl/fenvs, sys_impl/genargs, sys_impl/geninfos, sys_impl/genplatform, sys_impl/getencodings, sys_impl/sizes, sys_impl/stdio, sys_impl/util, time, time_impl/asctimeImpl, time_impl/converters, time_impl/measures, time_impl/nstrfptime, time_impl/private/doc_utils, time_impl/private/macro_utils, time_impl/sleep_impl, time_impl/strfptime, time_impl/struct_time_funcs, time_impl/types, types, warnings.

API symbols

`$`:

• dict: template `$`(self: PyDict): string
• dict: template `$`(self: PyDictItemView): string
• dict: template `$`(self: PyDictKeyView): string
• dict: template `$`(self: PyDictValueView): string
• list: template `$`(self: PyList): string
• pyrange: proc `$`[T](rng: PyRange[T]): string
• set_decl: template `$`(self: PyFrozenSet): string
• set_decl: template `$`(self: PySet): string
• set_decl: template `$`(self: SomePySet): string
• io_abc: proc `$`(p: CanIOOpenT): string
• io_abc: proc `$`(p: PathLike): string
• pybool: proc `$`(self: PyBool): string
• bytesimpl: proc `$`(self: PyBytes): string
• oserror_str: proc `$`(self: ref PyOSError): string
• signals: proc `$`(self: StopIteration): string
• signals: proc `$`(self: StopIterationT): string
• strimpl: proc `$`(self: PyStr): string
• translate: template `$`(table: TranslateTable): string
• wchar_utils: proc `$`(s; size = s.size): string
• wchar_utils: proc `$`(s; le: int): string
• isoformat: proc `$`(self: datetime): string
• meth: proc `$`(self: timedelta): string
• decl: proc `$`(self: timezone): string
• errnos: proc `$`(e: Errno): string
• members: proc `$`(t: MemberType): string
• walkImpl: template `$`[T](self: WalkRes[T]): string
• types: proc `$`(p: Path): string
• enums: proc `$`(self: Signals): string
• enums: proc `$`(self: Handlers): string
• enums: proc `$`(self: Sigmasks): string
• template_decl: proc `$`(self: Template): string

`%`:

• meth: proc `%`(self, t: timedelta): timedelta

`&=`:

• 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

`*=`:

• list: proc `*=`[T](self: var PyList[T]; n: int)

`*`:

• list: proc `*`[T](n: Natural; ls: PyList[T]): PyList[T]
• list: template `*`[T](ls: PyList[T]; n: Natural): PyList[T]
• strmeth: template `*`(i: int; a: StringLike): PyStr
• strmeth: template `*`(a: StringLike; i: int): PyStr
• meth: proc `*`(self: timedelta; f: float): timedelta
• meth: proc `*`(self: timedelta; i: int64): timedelta
• meth: proc `*`(f: float; self: timedelta): timedelta
• meth: proc `*`(i: int64; self: timedelta): timedelta

`+=`:

• list: proc `+=`[T](self: var PyList[T]; ls: openArray[T])
• list: proc `+=`[T](self: var PyList[T]; ls: PyList[T])
• 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)
• meth: proc `+=`(mself; t: timedelta)

`+`:

• 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
• cstring_ptr_op: template `+`[I: IndexType](s: cstring; i: I): cstring
• ptr_op: template `+`[I: IndexType; T](s: ptr T; i: I): ptr T
• op: proc `+`(self: datetime; delta: timedelta): datetime
• meth: proc `+`(self: timedelta): timedelta
• meth: proc `+`(a, b: timedelta): timedelta

`-=`:

• set: proc `-=`[H; S: SomeSet[H]](self: var SomePySet[H]; s: S)
• meth: proc `-=`(mself; t: timedelta)

`-`:

• 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]
• cstring_ptr_op: template `-`(a, b: cstring): ptrdiff_t
• ptr_op: template `-`[T](a, b: ptr T): ptrdiff_t
• op: proc `-`(self: datetime; dt: datetime): timedelta
• op: proc `-`(self: datetime; delta: timedelta): datetime
• meth: proc `-`(self: timedelta): timedelta
• meth: proc `-`(a, b: timedelta): timedelta

`.`:

• stat: template `.`(self: stat_result; attr): untyped

`//`:

• meth: proc `//`(self: timedelta; i: int): timedelta
• meth: proc `//`(self: timedelta; t: timedelta): int

`/=`:

• pathlib: proc `/=`(head: var Path; tail: PathLike): Path
• meth: proc `/=`(head: var Path; tail: string): Path

`/`:

• meth: proc `/`(self: timedelta; i: int | float): timedelta
• meth: proc `/`(self: timedelta; t: timedelta): float
• pathlib: proc `/`(self: Path; p: PathLike): Path
• pathlib: proc `/`(p: PathLike; self: Path): Path
• meth: proc `/`(self: Path; p: string): Path
• meth: proc `/`(p: string; self: Path): Path
• types: proc `/`(head, tail: Path): Path

`<%`:

• cstring_ptr_op: template `<%`(a, b: cstring): bool
• ptr_op: template `<%`[T](a, b: ptr T): bool

`<=%`:

• cstring_ptr_op: template `<=%`(a, b: cstring): bool
• ptr_op: template `<=%`[T](a, b: ptr T): bool

`<=`:

• list_decl: proc `<=`[A, B](self: PyList[A]; o: openArray[B]): bool
• list_decl: proc `<=`[A, B](self: PyList[A]; o: PyList[B]): bool
• list_decl: template `<=`[A, B](o: openArray[A]; self: PyList[B]): bool
• 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
• op: proc `<=`(self: datetime; dt: datetime): bool
• types: proc `<=`(st: struct_time; t: tuple): bool
• types: proc `<=`(t: tuple; st: struct_time): bool
• types: proc `<=`(a, b: struct_time): bool
• types: proc `<=`(a: struct_time; b: struct_time_tuple11): bool
• types: proc `<=`(a: struct_time_tuple11; b: struct_time): bool

`<>`:

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

`<`:

• list_decl: proc `<`[A, B](self: PyList[A]; o: openArray[B]): bool
• list_decl: proc `<`[A, B](self: PyList[A]; o: PyList[B]): bool
• list_decl: template `<`[A, B](o: openArray[A]; self: PyList[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
• op: proc `<`(self: datetime; dt: datetime): bool
• types: proc `<`(st: struct_time; t: tuple): bool
• types: proc `<`(t: tuple; st: struct_time): bool
• types: proc `<`(a, b: struct_time): bool
• types: proc `<`(a: struct_time; b: struct_time_tuple11): bool
• types: proc `<`(a: struct_time_tuple11; b: struct_time): bool

`==`:

• dict: proc `==`[A, B](self, other: PyDict[A, B]): bool
• list_decl: proc `==`[A, B](self: PyList[A]; o: openArray[B]): bool
• list_decl: proc `==`[A, B](self: PyList[A]; o: PyList[B]): bool
• list_decl: template `==`[A, B](o: openArray[A]; self: PyList[B]): 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: proc `==`[K, V](a, b: Mapping[K, V]): bool
• pybool: proc `==`(self: PyBool; opyb: PyBool): PyBool
• pybool: proc `==`(self: PyBool; b: bool): PyBool
• pybool: proc `==`(b: bool; self: PyBool): PyBool
• 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
• datetime: proc `==`(delta: timedelta; n: NoneType): bool
• datetime: proc `==`(tzinfo: tzinfo; n: NoneType): bool
• op: proc `==`(self: datetime; dt: datetime): bool
• decl: proc `==`(self: timedelta; o: timedelta): bool
• meth_else: proc `==`(self: timezone; o: timezone): bool
• types: proc `==`(head, tail: Path): bool
• enums: proc `==`(self: Handlers; other: Handlers): bool
• enums: proc `==`(self: Sigmasks; other: Sigmasks): bool
• enums: proc `==`(self: Signals; other: Signals): bool
• types: proc `==`(st: struct_time; t: tuple): bool
• types: proc `==`(t: tuple; st: struct_time): bool
• types: proc `==`(a, b: struct_time): bool
• types: proc `==`(a: struct_time; b: struct_time_tuple11): bool
• types: proc `==`(a: struct_time_tuple11; b: struct_time): bool

`@=`:

• obj_utils: proc `@=`[T](p1, p2: ref T): bool

`@`:

• list_decl: proc `@`[T](ls: PyList[T]): seq[T]
• collections: proc `@`[T](s: Sequence[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])
• list: proc `[]=`[T](ms: var PyList[T]; indices: Slice[int]; o: Sequence[T])
• wchar_t: proc `[]=`[I: csize_t | int](p: ptr wchar_t; i: I; val: wchar_t)
• float_view: proc `[]=`(fv: var VIEW32; _: range[0 .. 0]; f: float32)
• float_view: proc `[]=`(fv: var VIEW64; _: range[0 .. 0]; f: float64)

`[]`:

• 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
• 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
• ptr_op: template `[]`[I: IndexType; T](p: ptr T; i: I): T
• wchar_t: proc `[]`(p: ptr wchar_t; i: csize_t): wchar_t
• wchar_t: proc `[]`(p: ptr wchar_t; i: int): wchar_t
• float_view: proc `[]`(fv: VIEW32; _: range[0 .. 0]): float32
• float_view: proc `[]`(fv: VIEW64; _: range[0 .. 0]): float64
• stat: proc `[]`(self: stat_result; i: int): BiggestInt
• walkImpl: template `[]`[T](self: WalkRes[T]; i: static int): untyped
• enums: proc `[]`(cls: cls:type; name: string): Signals
• enums: proc `[]`(cls: cls:type; name: string): Handlers
• enums: proc `[]`(cls: cls:type; name: string): Sigmasks
• n_chainmap: proc `[]`[K, V](self: ChainMap[K, V]; k: K): V

`^`:

• 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`(self: PyBool; b: bool): PyBool
• pybool: proc `and`(b: bool; self: 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`(self: PyBool; b: bool): PyBool
• pybool: proc `or`(b: bool; self: 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:

• meth: proc abs(self: timedelta): timedelta

absolute:

• meth: proc absolute(self: Path): Path

abspath:

• path: proc abspath[T](s: PathLike[T]): T

accessHighLow:

• indices: template accessHighLow(body)

AC_CHECK_FUNC:

• util: template AC_CHECK_FUNC(function)
• util: template AC_CHECK_FUNC(res, function)

AC_CHECK_FUNCS:

• util: macro AC_CHECK_FUNCS(functions: varargs[untyped]): untyped

accumulate:

• n_itertools: iterator accumulate[T](iterable: openArray[T]; binop: BinOp[T] = binOpAdd; inital = mayZeroDefault(T)): T

AC_LINK_IFELSE:

• util: template AC_LINK_IFELSE(variable, defval, code)

aclose:

• asyncs: proc aclose(self: AsyncGenerator): owned(Future[void])

ac_md_release:

• platformInfo: proc ac_md_release(): string

acos:

• math: proc acos[F: SomeFloat](x: F): F
• n_math: proc acos[F: SomeFloat](x: F): F

acosh:

• math: proc acosh[F: SomeFloat](x: F): F
• n_math: proc acosh[F: SomeFloat](x: F): F

AC_RUN_IFELSE:

• util: template AC_RUN_IFELSE(variable, defval, code)

add:

• set: proc add[H](self: var PySet[H]; x: H)
• ops: proc add(t1, t2: PyTime): PyTime
• abc_set: proc add(self: var SomeSet[int]; i: int)

add_alias:

• enums: proc add_alias(self: Signals; name: string)
• enums: proc add_alias(self: Handlers; name: string)
• enums: proc add_alias(self: Sigmasks; name: string)

addEachIter:

• macroutils: proc addEachIter(loopBody: NimNode; nIt: int; itors, res: NimNode; preBreakCb: PreBreakCb = noopPreBreakCb)

addFields:

• macro_utils: macro addFields(res: string; obj: typed; noMoreThan: static[int] = int.high)

add_format_utcoffset:

• format_utcoffset: proc add_format_utcoffset(s: var string; sep: string; tzinfo: tzinfo; tzinfoarg: datetime)

addLoopEach:

• macroutils: proc addLoopEach(loopBody: NimNode; parent: NimNode; iterables: NimNode | seq[NimNode]; res = ident preferredGenIterResName; preBreakCb: PreBreakCb = noopPreBreakCb): NimNode

add_member:

• enums: proc add_member(enum_class: typedesc[Handlers]; name: string; value: int): Handlers
• enums: proc add_member(enum_class: typedesc[Sigmasks]; name: string; value: int): Sigmasks
• enums: proc add_member(enum_class: typedesc[Signals]; name: string; value: int): Signals

addPatch:

• utils: template addPatch(ver: (int, int, int); flag: untyped; patchBody: untyped)

addResDecl:

• macroutils: proc addResDecl(body: NimNode; iterables: NimNode | seq[NimNode]; res = ident preferredGenIterResName; iters = genSym(nskLet, "iters")): NimNode

add_sigset:

• sigset_to_set: proc add_sigset(res: var Set[int]; mask: var Sigset)

addYield:

• macroutils: proc addYield(res, dest: NimNode)

alarm:

• unixs: proc alarm(seconds: int): int

ALIGNOF_SIZE_T:

• codecs: const ALIGNOF_SIZE_T

all:

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

allAlpha:

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

allocWcharArr:

• wchar_t: template allocWcharArr[I](n: I): ptr wchar_t

allTrue:

• members: template allTrue(_): bool

altsep:

• consts: let altsep

ANDROID_API:

• ver: const ANDROID_API

anext:

• asyncs: proc anext[T](self: AsyncGenerator[T]): Awaitable[T]
• asyncs: proc anext[T](self: AsyncGenerator[T]; default: T): Awaitable[T]

any:

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

append:

• list: proc append[T](self: var PyList[T]; x: T)
• collections: proc append[T](ms: MutableSequence[T]; x: T)

APPLE:

• defines: const APPLE

argv:

• n_sys: var argv
• sys: var argv

ArithmeticError:

• aritherr: 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

ASCII_CHAR_MASK:

• codecs: const ASCII_CHAR_MASK

ascii_letters:

• string: const ascii_letters
• consts: const ascii_letters

ascii_lowercase:

• string: const ascii_lowercase
• consts: const ascii_lowercase

ascii_uppercase:

• string: const ascii_uppercase
• consts: const ascii_uppercase

asctime:

• n_time: proc asctime(): string
• n_time: proc asctime(t: struct_time): string
• n_time: proc asctime(tup: struct_time_tuple): typeof(asctime do: bind struct_time struct_time(tm_year: 1900, tm_mon: 1, tm_mday: 1, tm_yday: 1, tm_isdst: -1))
• n_time: proc asctime(tup: struct_time_tuple10): typeof(asctime do: bind struct_time struct_time(tm_year: 1900, tm_mon: 1, tm_mday: 1, tm_yday: 1, tm_isdst: -1))
• n_time: proc asctime(tup: struct_time_tuple11): typeof(asctime do: bind struct_time struct_time(tm_year: 1900, tm_mon: 1, tm_mday: 1, tm_yday: 1, tm_isdst: -1))
• time: proc asctime(): PyStr
• time: proc asctime(t: Some_struct_time): PyStr
• asctimeImpl: proc asctime(dt: DateTime): string

asctimeImpl:

• asctimeImpl: template asctimeImpl(result: string; dt: DateTime)

asDuration:

• decl: proc asDuration(self: timedelta): Duration

asgSeqToObj:

• macro_utils: macro asgSeqToObj(tup, obj: typed)

asHashSet:

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

asin:

• math: proc asin[F: SomeFloat](x: F): F
• n_math: proc asin[F: SomeFloat](x: F): F

asinh:

• math: proc asinh[F: SomeFloat](x: F): F
• n_math: proc asinh[F: SomeFloat](x: F): F

asNimDatetime:

• inner_decl: proc asNimDatetime(self: datetime): DateTime

as_posix:

• meth: proc as_posix(self: Path): Path

asSeq:

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

asTimeval:

• pytimeAsTimeval: proc asTimeval(t: PyTime; round: PyTime_round_t): Timeval

astimezone:

• aszone: proc astimezone(self: datetime; tz = TzNone): datetime

asVersion:

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

AsyncGenerator:

• asyncs: type AsyncGenerator

AsyncIterable:

• asyncs: type AsyncIterable

AsyncIterator:

• asyncs: type AsyncIterator

atan:

• math: proc atan[F: SomeFloat](x: F): F
• n_math: proc atan[F: SomeFloat](x: F): F

atan2:

• math: proc atan2[F: SomeFloat](x, y: F): F
• n_math: proc atan2[F: SomeFloat](x: F): F

atanh:

• math: proc atanh[F: SomeFloat](x: F): F
• n_math: proc atanh[F: SomeFloat](x: F): F

AttributeError:

• simperr: object AttributeError

await:

• asyncs: proc await[T](self: anextawaitableobject[T]): T

Awaitable:

• asyncs: type Awaitable

AX_C_FLOAT_WORDS_BIGENDIAN:

• util: template AX_C_FLOAT_WORDS_BIGENDIAN(id; doIfTrue, doIfFalse, doIfUnknown)

AX_C_FLOAT_WORDS_BIGENDIAN_def:

• util: template AX_C_FLOAT_WORDS_BIGENDIAN_def(defIfTrue, defIfFalse, doIfUnknown)

basename:

• path: proc basename[T](s: PathLike[T]): T

BeforeFixedVer:

• abs: const BeforeFixedVer
• nansign: const BeforeFixedVer
• newUninit: const BeforeFixedVer

betavariate:

• proc_others: proc betavariate(self: PyRandom; alpha, beta: float): float
• proc_others: template betavariate(alpha, beta: float): float

BIAS:

• consts: template BIAS[F](_: typedesc[F]): F

bin:

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

binomialvariate:

• proc_others: proc binomialvariate(self: PyRandom; n = 1.0; p = 0.5): float
• proc_others: template binomialvariate(n = 1.0; p = 0.5): float

BinOp:

• n_itertools: type BinOp

binOpAdd:

• n_itertools: proc binOpAdd[T](x, y: T): T

bisect:

• n_bisect: proc bisect[T, K](a: openArray[T]; x: K; lo = 0; hi = a.len; key: Key[T, K]): int
• n_bisect: proc bisect[T](a: openArray[T]; x: T; lo = 0; hi = a.len): int

bisect_left:

• n_bisect: proc bisect_left[T, K](a: openArray[T]; x: K; lo = 0; hi = a.len; key: Key[T, K]): int
• n_bisect: proc bisect_left[T](a: openArray[T]; x: T; lo = 0; hi = a.len): int

bisect_right:

• n_bisect: proc bisect_right[T, K](a: openArray[T]; x: K; lo = 0; hi = a.len; key: Key[T, K]): int
• n_bisect: proc bisect_right[T](a: openArray[T]; x: T; lo = 0; hi = a.len): int

BlockingIOError:

• init: proc BlockingIOError(myerrno: cint; strerr: string; filename = 0; winerror: cint = 0; filename2 = ""): ref PyOSError
• types: object BlockingIOError

bodySetItem:

• mutSeqSliceOp: template bodySetItem(Arr)

bool:

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

BrokenPipeError:

• types: object BrokenPipeError

BufferedIOBase:

• io: type BufferedIOBase

BufferedRandom:

• io: type BufferedRandom

BufferedReader:

• io: type BufferedReader

BufferedWriter:

• io: type BufferedWriter

byteLen:

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

byteorder:

• n_sys: const byteorder
• sys: const byteorder

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[SomeInteger]): PyBytes
• bytesimpl: proc bytes(s: openArray[char | uint8]): PyBytes
• bytesimpl: proc bytes(s: sink string): PyBytes
• bytesimpl: proc bytes(self: PyBytes): PyBytes

CanIOOpenT:

• io_abc: type CanIOOpenT

capitalize:

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

capwords:

• n_string: proc capwords(a: string): string
• n_string: proc capwords(a: string; sep: string): string
• string: proc capwords(a: StringLike): PyStr
• string: proc capwords(a: StringLike; _: NoneType): PyStr
• string: proc capwords(a: StringLike; sep: StringLike): PyStr

casefold:

• strmeth: proc casefold(a: PyStr): PyStr

cbrt:

• math: proc cbrt[F: SomeFloat](x: F): F
• cbrt: proc cbrt[F: SomeFloat](x: F): F
• cbrt: proc cbrt[F: SomeFloat](x: F): F

c_defined:

• util: template c_defined(variable; c_macro: string; headers: openArray = [])

ceil:

• n_math: proc ceil(x: SomeFloat): int

center:

• 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

c_fma:

• fma: proc c_fma(x, y, z: cdouble): cdouble
• fma: proc c_fma(x, y, z: cfloat): cfloat

c_getenv:

• envutils: proc c_getenv(v: cstring): cstring

ChainMap:

• n_chainmap: object ChainMap

chars:

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

chdir:

• utils: proc chdir(s: PathLike)

checked_resource:

• funcs: proc checked_resource(resource: int): cint

check_force_ascii:

• force_ascii_utils: proc check_force_ascii(): bool

checkLenientOps:

• list_decl: template checkLenientOps(A, B)

ChildProcessError:

• types: object ChildProcessError

chkOneDay:

• delta_chk: template chkOneDay(delta: timedelta)

chkSigRng:

• chk_util: proc chkSigRng(signalnum: cint | int)

choice:

• random: proc choice[T](self: PyRandom; ls: Sequence[T]): T
• random: template choice[T](ls: Sequence[T]): T
• proc_dispatched: proc choice[T](self: PyRandom; data: openArray[T]): T
• proc_dispatched: template choice[T](data: openArray[T]): T

choices:

• random: proc choices[T](self: PyRandom; population: Sequence[T]; weights: NoneType | Sequence[T] = None; cum_weights: NoneType | Sequence[T] = None; k = 1): PyList[T]
• random: template choices[T](population: Sequence[T]; weights: NoneType | Sequence[T] = None; cum_weights: NoneType | Sequence[T] = None; k = 1): PyList[T]
• proc_others: proc choices[T](self: PyRandom; population: openArray[T]; weights = none(openArray[T]); cum_weights = none(openArray[T]); k = 1): seq[ T]
• proc_others: template choices[T](population: openArray[T]; weights = none(openArray[T]); cum_weights = none(openArray[T]); k = 1): seq[T]

chr:

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

c_ldexp:

• ldexp: proc c_ldexp[F: SomeFloat](x: F; exp: cint): F

cleandoc:

• inspect: template cleandoc(obj: PyStr): PyStr
• n_inspect: proc cleandoc(s: string): string

clear:

• dict: proc clear(self: PyDict)
• list: proc clear(self: var PyList)
• set_decl: proc clear(self: var PySet): int
• collections: proc clear(ms: MutableSequence)

CLEAR_EXP_MASK:

• consts: template CLEAR_EXP_MASK[F](): untyped

CLike:

• platformUtils: const CLike

clikeOr:

• platformUtils: template clikeOr(inCLike, b): untyped

close:

• asyncs: proc close(self: Coroutine)
• generators: proc close(self: Generator)
• io: method close(self: IOBase)
• io: method close(self: RawIOBase)
• io: method close(self: TextIOWrapper)
• os: template close(p: DirEntry)
• open_close: proc close(fd: int)
• scandirImpl: proc close(scandirIter: ScandirIterator)

closeImpl:

• templ: template closeImpl(msg: string; throwBody)

closerange:

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

ClosureIter:

• niter_types: type ClosureIter

cmpOnField:

• macro_utils: macro cmpOnField(a, b: typed): int

CmpStragy:

• macro_utils: enum CmpStragy

Collection:

• collections: type Collection

comb:

• math: proc comb(n, k: int): int
• n_math: proc comb(n, k: int): int

combinations:

• n_itertools: iterator combinations[T](iterable: openArray[T]; r: int): seq[T]

CompileBackend:

• backendMark: enum CompileBackend

compileLittleEndian:

• assertIsLittleEndian: const compileLittleEndian

ConnectionAbortedError:

• types: object ConnectionAbortedError

ConnectionError:

• types: object ConnectionError

ConnectionRefusedError:

• types: object ConnectionRefusedError

ConnectionResetError:

• types: object ConnectionResetError

CONST_EPOCH:

• state_consts: let CONST_EPOCH

Container:

• collections: 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: proc contains[T](s: Container[T]; x: T): bool
• collections: proc contains[K, V](m: Mapping[K, V]; k: K): 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
• enums: proc contains(cls: cls:type; value: int): bool
• enums: proc contains(cls: cls:type; value: int): bool
• enums: proc contains(cls: cls:type; value: int): bool
• enums: template contains(cls; value: Handlers): bool
• enums: template contains(cls; value: Sigmasks): bool
• enums: template contains(cls; value: Signals): bool
• n_chainmap: proc contains[K, V](self: ChainMap[K, V]; k: K): bool

copy:

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

copyright:

• n_sys: const copyright
• sys: const copyright

copysign:

• math: proc copysign[F: SomeFloat](x, y: F): F

Coroutine:

• asyncs: type Coroutine

cos:

• math: proc cos[F: SomeFloat](x: F): F

cosh:

• math: proc cosh[F: SomeFloat](x: F): F

count:

• pyrange: proc count[T](r: PyRange[T]; x: T): int
• collections: proc count[T](s: Sequence[T]; x: T): 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

c_raise:

• signal_util: proc c_raise(signalnum: cint): cint

csEq:

• macro_utils: CmpStragy.csEq

c_setlocale:

• localeutils: proc c_setlocale(category: cint; v: cstring): cstring

CSigHandler:

• handler_types: type CSigHandler

c_signal:

• c_syms: proc c_signal(a1: cint; a2: CSigHandler): CSigHandler

csLhs:

• macro_utils: CmpStragy.csLhs

csRhs:

• macro_utils: CmpStragy.csRhs

csShorter:

• macro_utils: CmpStragy.csShorter

ctime:

• datetime: proc ctime(self: datetime): PyStr
• require_time_module: proc ctime(self: datetime): string
• n_time: proc ctime(): string
• n_time: proc ctime(secs: float | int64): string
• time: proc ctime(): PyStr
• time: proc ctime(secs: float | int64): PyStr

cTmToNormCall:

• struct_tm_helper: macro cTmToNormCall(call; tm: Tm; kwargs: varargs[untyped]): untyped

curdir:

• consts: let curdir

cwd:

• meth: proc cwd(_: typedesc[Path]): Path

datetime:

• inner_decl: type datetime
• init: proc datetime(year, month, day: int; hour = 0; minute = 0; second = 0; microsecond = 0; tzinfo: tzinfo = nil; fold = 0): datetime

datetime_fromisoformat:

• fromisoformat: proc datetime_fromisoformat(dtstr: string): datetime

day:

• inner_decl: proc day(self: datetime): int

days:

• getter: proc days(self: timedelta): int64

days_before_month:

• calendar_utils: proc days_before_month(year, month: int): int

daysImpl:

• getter: proc daysImpl(parts: DurationParts): int64

deallocWcArr:

• wchar_t: template deallocWcArr(p: ptr wchar_t)

decl_c_int:

• errmap: template decl_c_int(name, includeFile; defval)

declErrorcodeWith:

• errorcodeInit: template declErrorcodeWith[K, V](initFunc: typed)

DeclIntEnumMeth:

• intEnum: template DeclIntEnumMeth(Self; Int = int; genObjMeth = true; genInit = false)

declTupleWithNFieldsFrom:

• macro_utils: macro declTupleWithNFieldsFrom(name: untyped; Cls: typedesc; n: static[int]; exported: static[bool] = true)

DECODE_ERROR:

• wchar_t: const DECODE_ERROR

DEFAULT_BUFFER_SIZE:

• io: const DEFAULT_BUFFER_SIZE

default_int_handler:

• signals: proc default_int_handler(signalnum: int; frame: PFrame)

default_oserror:

• errmap: proc default_oserror(): ref PyOSError

DefaultTimeFormat:

• n_time: const DefaultTimeFormat
• time: const DefaultTimeFormat

DefEncoding:

• io: const DefEncoding

DefErrors:

• ncodec: const DefErrors

DefNewLine:

• io: const DefNewLine

defpath:

• consts: const defpath

DEF_SIG:

• signal: const DEF_SIG

DefSplitCap:

• common: const DefSplitCap

degrees:

• n_math: proc degrees[F: SomeFloat](x: F): F

Delimiter:

• substituteImpl: const Delimiter

delimiter:

• template_decl: method delimiter(self: Template): char

delitem:

• dict: proc delitem[K, V](self: PyDict[K, V]; k: K)
• list: proc delitem(self: var PyList; idx: int)
• list: proc delitem(ms: var PyList; indices: PySlice)
• list: proc delitem(ms: var PyList; indices: Slice[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)

digits:

• string: const digits
• consts: const digits

DirEntry:

• scandirImpl: type DirEntry

dirname:

• path: proc dirname[T](s: PathLike[T]): T

dist:

• math: template dist[T](p, q: (Iterable[T] and not openArray[T])): float
• math: template dist[T](p, q: ClosureIter[T]): float
• math: template dist[T](p, q: list[T]): float
• math: template dist[T](p, q: openArray[T]): float
• dist: proc dist[A, B](p, q: (A, B)): float
• dist: proc dist[A, B, C](p, q: (A, B, C)): float
• dist: proc dist[T; I: static[int]](p, q: array[I, T]): float

dist_checkedSameLen:

• niter_types: proc dist_checkedSameLen[T](p, q: T): int

divide:

• ops: proc divide(t, k: PyTime; round: PyTime_round_t): PyTime

divide_round_up:

• ops: proc divide_round_up(t, k: PyTime): PyTime

divmod:

• ops: proc divmod(t, k: PyTime; pq, pr: var PyTime): bool
• mathutils: proc divmod[I](x: I; y: Natural; r: var I): I
• meth: proc divmod(t1, t2: timedelta): (int64, timedelta)

dl_mul:

• dl_ops: proc dl_mul(x: float; y: float): DoubleLength

dl_sum:

• dl_ops: proc dl_sum(a, b: float): DoubleLength

docTable:

• nstrfptime: const docTable

DocTable:

• doc_utils: object DocTable

DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754:

• floats: const DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754

DOUBLE_IS_BIG_ENDIAN_IEEE754:

• floats: const DOUBLE_IS_BIG_ENDIAN_IEEE754

DOUBLE_IS_LITTLE_ENDIAN_IEEE754:

• floats: const DOUBLE_IS_LITTLE_ENDIAN_IEEE754

DoubleLength:

• dl_ops: object DoubleLength

dst:

• getter: proc dst(self: datetime): timedelta
• meth_by_datetime_getter: method dst(self: timezone; _: datetime): timedelta
• meth_by_datetime_getter: method dst(self: tzinfo; dt: datetime): timedelta

dtToStructTime:

• converters: proc dtToStructTime(dt: DateTime; res: var struct_time)

dunder_stderr:

• stdio: let dunder_stderr

dunder_stdin:

• stdio: let dunder_stdin

dunder_stdout:

• stdio: let dunder_stdout

DW:

• defines: const DW

DWin:

• state: const DWin

e:

• n_math: const e

E2BIG:

• errnoConsts: let E2BIG

EACCES:

• errnoConsts: let EACCES

EADDRINUSE:

• errnoConsts: let EADDRINUSE

EADDRNOTAVAIL:

• errnoConsts: let EADDRNOTAVAIL

EADV:

• errnoConsts: let EADV

EAFNOSUPPORT:

• errnoConsts: let EAFNOSUPPORT

EAGAIN:

• errnoConsts: let EAGAIN

EALREADY:

• errnoConsts: let EALREADY

EBADE:

• errnoConsts: let EBADE

EBADF:

• errnoConsts: let EBADF

EBADFD:

• errnoConsts: let EBADFD

EBADMSG:

• errnoConsts: let EBADMSG

EBADR:

• errnoConsts: let EBADR

EBADRQC:

• errnoConsts: let EBADRQC

EBADSLT:

• errnoConsts: let EBADSLT

EBFONT:

• errnoConsts: let EBFONT

EBUSY:

• errnoConsts: let EBUSY

ECANCELED:

• errnoConsts: let ECANCELED

ECHILD:

• errnoConsts: let ECHILD

ECHRNG:

• errnoConsts: let ECHRNG

ECOMM:

• errnoConsts: let ECOMM

ECONNABORTED:

• errnoConsts: let ECONNABORTED

ECONNREFUSED:

• errnoConsts: let ECONNREFUSED

ECONNRESET:

• errnoConsts: let ECONNRESET

EDEADLK:

• errnoConsts: let EDEADLK

EDEADLOCK:

• errnoConsts: let EDEADLOCK

EDESTADDRREQ:

• errnoConsts: let EDESTADDRREQ

EDOM:

• errnoConsts: let EDOM

EDOTDOT:

• errnoConsts: let EDOTDOT

EDQUOT:

• errnoConsts: let EDQUOT

EEXIST:

• errnoConsts: let EEXIST

EFAULT:

• errnoConsts: let EFAULT

EFBIG:

• errnoConsts: let EFBIG

EHOSTDOWN:

• errnoConsts: let EHOSTDOWN

EHOSTUNREACH:

• errnoConsts: let EHOSTUNREACH

EIDRM:

• errnoConsts: let EIDRM

EILSEQ:

• errnoConsts: let EILSEQ

EINPROGRESS:

• errnoConsts: let EINPROGRESS

EINTR:

• errnoConsts: let EINTR

EINVAL:

• errno_decl: let EINVAL
• errnoConsts: let EINVAL

EIO:

• errnoConsts: let EIO

EISCONN:

• errnoConsts: let EISCONN

EISDIR:

• errnoConsts: let EISDIR

EISNAM:

• errnoConsts: let EISNAM

EKEYEXPIRED:

• errnoConsts: let EKEYEXPIRED

EKEYREJECTED:

• errnoConsts: let EKEYREJECTED

EKEYREVOKED:

• errnoConsts: let EKEYREVOKED

EL2HLT:

• errnoConsts: let EL2HLT

EL2NSYNC:

• errnoConsts: let EL2NSYNC

EL3HLT:

• errnoConsts: let EL3HLT

EL3RST:

• errnoConsts: let EL3RST

ELIBACC:

• errnoConsts: let ELIBACC

ELIBBAD:

• errnoConsts: let ELIBBAD

ELIBEXEC:

• errnoConsts: let ELIBEXEC

ELIBMAX:

• errnoConsts: let ELIBMAX

ELIBSCN:

• errnoConsts: let ELIBSCN

ELNRNG:

• errnoConsts: let ELNRNG

ELOOP:

• errnoConsts: let ELOOP

EMEDIUMTYPE:

• errnoConsts: let EMEDIUMTYPE

EMFILE:

• errnoConsts: let EMFILE

EMLINK:

• errnoConsts: let EMLINK

emptyn:

• macroutils: let emptyn

emptyPyDict:

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

EMSGSIZE:

• errnoConsts: let EMSGSIZE

EMULTIHOP:

• errnoConsts: let EMULTIHOP

ENAMETOOLONG:

• errnoConsts: let ENAMETOOLONG

ENAVAIL:

• errnoConsts: let ENAVAIL

EncErrors:

• ncodec: enum EncErrors

encoding:

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

encodings.normalize_encoding:

• encoding_norm: proc encodings.normalize_encoding(encoding: string): string

endsWith:

• 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

ENETDOWN:

• errnoConsts: let ENETDOWN

ENETRESET:

• errnoConsts: let ENETRESET

ENETUNREACH:

• errnoConsts: let ENETUNREACH

ENFILE:

• errnoConsts: let ENFILE

ENOANO:

• errnoConsts: let ENOANO

ENOBUFS:

• errnoConsts: let ENOBUFS

ENOCSI:

• errnoConsts: let ENOCSI

ENODATA:

• errnoConsts: let ENODATA

ENODEV:

• errnoConsts: let ENODEV

ENOENT:

• errnoConsts: let ENOENT

ENOEXEC:

• errnoConsts: let ENOEXEC

ENOKEY:

• errnoConsts: let ENOKEY

ENOLCK:

• errnoConsts: let ENOLCK

ENOLINK:

• errnoConsts: let ENOLINK

ENOMEDIUM:

• errnoConsts: let ENOMEDIUM

ENOMEM:

• errnoConsts: let ENOMEM

ENOMSG:

• errnoConsts: let ENOMSG

ENONET:

• errnoConsts: let ENONET

ENOPKG:

• errnoConsts: let ENOPKG

ENOPROTOOPT:

• errnoConsts: let ENOPROTOOPT

ENOSPC:

• errnoConsts: let ENOSPC

ENOSR:

• errnoConsts: let ENOSR

ENOSTR:

• errnoConsts: let ENOSTR

ENOSYS:

• errnoConsts: let ENOSYS

ENOTBLK:

• errnoConsts: let ENOTBLK

ENOTCAPABLE:

• errmap: const ENOTCAPABLE

ENOTCONN:

• errnoConsts: let ENOTCONN

ENOTDIR:

• errnoConsts: let ENOTDIR

ENOTEMPTY:

• errnoConsts: let ENOTEMPTY

ENOTNAM:

• errnoConsts: let ENOTNAM

ENOTRECOVERABLE:

• errnoConsts: let ENOTRECOVERABLE

ENOTSOCK:

• errnoConsts: let ENOTSOCK

ENOTSUP:

• errnoConsts: let ENOTSUP

ENOTTY:

• errnoConsts: let ENOTTY

ENOTUNIQ:

• errnoConsts: let ENOTUNIQ

enter:

• io: proc enter[IO: IOBase](self: IO): IO

enumerate:

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

ENXIO:

• errnoConsts: let ENXIO

EOPNOTSUPP:

• errnoConsts: let EOPNOTSUPP

EOVERFLOW:

• errnoConsts: let EOVERFLOW

EOWNERDEAD:

• errnoConsts: let EOWNERDEAD

EPERM:

• errnoConsts: let EPERM

EPFNOSUPPORT:

• errnoConsts: let EPFNOSUPPORT

EPIPE:

• errnoConsts: let EPIPE

epoch:

• to_seconds_utils: let epoch

EPROTO:

• errnoConsts: let EPROTO

EPROTONOSUPPORT:

• errnoConsts: let EPROTONOSUPPORT

EPROTOTYPE:

• errnoConsts: let EPROTOTYPE

ERANGE:

• errnoConsts: let ERANGE

EREMCHG:

• errnoConsts: let EREMCHG

EREMOTE:

• errnoConsts: let EREMOTE

EREMOTEIO:

• errnoConsts: let EREMOTEIO

ERESTART:

• errnoConsts: let ERESTART

erf:

• math: proc erf[F: SomeFloat](x: F): F

erfc:

• math: proc erfc[F: SomeFloat](x: F): F

ERFKILL:

• errnoConsts: let ERFKILL

EROFS:

• errnoConsts: let EROFS

errno:

• errno_decl: var errno

Errno:

• errnos: enum Errno

errno:

• singleton_errno: var errno

ErrnoCount:

• errnos: const ErrnoCount

errnomap:

• errmap: var errnomap

errnoMsg:

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

errors:

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

ESHUTDOWN:

• errmap: const ESHUTDOWN
• errnoConsts: let ESHUTDOWN

ESOCKTNOSUPPORT:

• errnoConsts: let ESOCKTNOSUPPORT

ESPIPE:

• errnoConsts: let ESPIPE

ESRCH:

• errnoConsts: let ESRCH

ESRMNT:

• errnoConsts: let ESRMNT

ESTALE:

• errnoConsts: let ESTALE

ESTRPIPE:

• errnoConsts: let ESTRPIPE

ETIME:

• errnoConsts: let ETIME

ETIMEDOUT:

• errnoConsts: let ETIMEDOUT

ETOOMANYREFS:

• errnoConsts: let ETOOMANYREFS

ETXTBSY:

• errnoConsts: let ETXTBSY

EUCLEAN:

• errnoConsts: let EUCLEAN

EULER:

• consts: const EULER

EUNATCH:

• errnoConsts: let EUNATCH

EUSERS:

• errnoConsts: let EUSERS

EWOULDBLOCK:

• errnoConsts: let EWOULDBLOCK

excl:

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

EXDEV:

• errnoConsts: let EXDEV

executable:

• n_sys: template executable(): string
• sys: template executable(): PyStr

EXFULL:

• errnoConsts: let EXFULL

exit:

• io: template exit(self: IOBase; args: varargs[untyped])
• sys: proc exit(x: NoneType)
• sys: proc exit[T](obj: T)
• exits: proc exit(c: int)
• exits: proc exit(s: string)

exp:

• math: proc exp[F: SomeFloat](x: F): F

expandtabs:

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

expandtabsImpl:

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

expm1:

• math: proc expm1[F: SomeFloat](x: F): F
• expm1: proc expm1[F: SomeFloat](x: F): F
• expm1_log1p: proc expm1[F: SomeFloat](x: F): F

EXP_MASK:

• consts: template EXP_MASK[F](): untyped

exponent:

• exponent: proc exponent[F: SomeFloat](x: F): BiggestInt

exportAllErrnosViaEnumOrImportc:

• exportUtils: macro exportAllErrnosViaEnumOrImportc()

expovariate:

• proc_others: proc expovariate(self: PyRandom; lambd = 1.0): float
• proc_others: template expovariate(lambd = 1.0): float

extend:

• list: proc extend[T](self: var PyList[T]; ls: openArray[T])
• list: template extend[T](self: var PyList[T]; ls: Iterable[T])
• collections: proc extend[T](ms: MutableSequence[T]; it: Iterable[T])

extsep:

• consts: let extsep

f:

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

fabs:

• math: proc fabs[F: SomeFloat](x: F): F
• n_math: proc fabs[F: SomeFloat](x: F): F

factorial:

• math: proc factorial(x: int): int
• n_math: proc factorial(x: Natural): int

False:

• pybool: const False

fdopen:

• fdopen: template fdopen(fd: Positive; x: varargs[untyped]): untyped

fetchDoc:

• doc_utils: macro fetchDoc(tab: static DocTable)
• doc_utils: macro fetchDoc(tab: static DocTable; def)

FI:

• meth: type FI

FileExistsError:

• types: object FileExistsError

FileIO:

• io: type FileIO

filemode:

• stat: proc filemode(omode: int | Mode): PyStr
• strrepr: proc filemode(omode: int): string
• strrepr: proc filemode(omode: Mode): string

fileno:

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

FileNotFoundError:

• types: object FileNotFoundError

fill_siginfo:

• siginfo_decl: proc fill_siginfo(si: SigInfo): struct_siginfo

fill_valid_signals:

• valid_signals_impl: proc fill_valid_signals(res: var Set[int])

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:

• 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

FixedVer:

• abs: const FixedVer
• nansign: const FixedVer
• newUninit: const FixedVer

float_info:

• fenvs: const float_info

float_repr_style:

• sys: const float_repr_style
• fenvs: const float_repr_style

floor:

• n_math: proc floor(x: SomeFloat): int

flush:

• io: proc flush(f: IOBase)

flush_hash:

• decl: proc flush_hash(self: timedelta)

fma:

• math: proc fma[F: SomeFloat](x, y, z: F): F
• fma: proc fma[F: SomeFloat](x, y, z: F): F
• fma: proc fma[F: SomeFloat](x, y, z: F; exc: var ref Exception): F

fmod:

• math: proc fmod[F: SomeFloat](x: F; y: F): F
• n_math: proc fmod[F: SomeFloat](x: F; y: F): F

fold:

• inner_decl: proc fold(self: datetime): int

force_ascii:

• force_ascii_utils: template force_ascii(): untyped

forErrno:

• loopErrno: template forErrno(res: NimNode; err; body)

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
• formats: proc format(self: datetime; format_spec = ""): string

format_utcoffset:

• decl: proc format_utcoffset(parts: DurationParts; sep: string | char = ':'; prefix = "UTC"): string

formatValue:

• formats: proc formatValue(result: var string; value: datetime; specifier: string)

fr:

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

Fr:

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

freeZoneCStr:

• zonename_utils: proc freeZoneCStr(s: cstring)

frexp:

• frexp: proc frexp[F: SomeFloat](x: F): (F, int)
• frexp: proc frexp[F: SomeFloat](x: F; e: var int): F
• frexp: proc frexp[F: SomeFloat](x: F): (F, int)

from_c_int:

• util: template from_c_int(variable; defvar: int): int
• util: template from_c_int(variable; defval: int; precode): int
• util: template from_c_int(variable; includeFile: static[string]; defval = low(int)): int

from_c_int_expr:

• util: macro from_c_int_expr(cExpr: static[string]; defval: int): int

from_c_int_underlined:

• util: macro from_c_int_underlined(variable: static[string]; defval: int): int

fromisocalendar:

• statics: proc fromisocalendar(_: _`gensym1744830498:type; year, week, day: int): datetime

fromisoformat:

• statics: proc fromisoformat(_: _`gensym1744830487:type; nonkw: string): datetime

fromIterable:

• sigsetCvt: template fromIterable(result: var Sigset; obj)

fromordinal:

• statics: proc fromordinal(_: _`gensym1744830492:type; ordinal: int): datetime

fromSecondsObject:

• pytimeFromSeconds: proc fromSecondsObject(tp; obj: Timestamp; round: PyTime_round_t)

fromtimestamp:

• statics: proc fromtimestamp(_: _`gensym1744830592:type; timestamp: Timestamp; tz = TzNone): datetime

fromutc:

• meth_by_datetime: method fromutc(self: timezone; dt: datetime): datetime
• meth_by_datetime: method fromutc(self: tzinfo; dt: datetime): datetime

fromWords:

• fromWords: proc fromWords(high, low: uint16): float32
• fromWords: proc fromWords(high, low: uint32): float

frozenset:

• set: proc frozenset[H](): PyFrozenSet[H]
• 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_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
• pathlib: proc fspath(self: Path): PyStr

fsum:

• n_math: proc fsum[T: SomeFloat](iterable: Iterable[T]): T

ftruncate:

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

gamma:

• math: proc gamma[F: SomeFloat](x: F): F
• gamma: proc gamma[F: SomeFloat](x: F): F
• gamma: proc gamma[T: SomeFloat](x: T; res: var T): GammaError
• n_math: proc gamma[F: SomeFloat](x: F): F

GammaError:

• err: enum GammaError

gammavariate:

• proc_others: proc gammavariate(self: PyRandom; alpha, beta: float): float
• proc_others: template gammavariate(alpha, beta: float): float

gcd:

• n_math: proc gcd[I: SomeInteger](x, y: I): I
• n_math: proc gcd[I: SomeInteger](x, y, z: I; args: varargs[I]): I

geDom:

• err: GammaError.geDom

geGotNegInf:

• err: GammaError.geGotNegInf

genArgs:

• genargs: template genArgs(St, Ls; S; lsCopy, lsOfCap)

genCapwords:

• capwordsImpl: template genCapwords(Arg, Res, split, split2, capitalize, strip)

genDelItem:

• mutSeqSliceOp: template genDelItem(Arr)

genDollarRepr:

• strIter: template genDollarRepr(Coll; start, stop: char | string; linear = false; useIter = true)
• strIter: template genDollarRepr(Coll; start, stop: char | string; strProc: typed; linear = false; useIter = true)

Generator:

• generators: type Generator

GeneratorExit:

• signals: object GeneratorExit

genGbl:

• macroutils: macro genGbl(decl)

genGbls:

• macroutils: macro genGbls(decls)

genGenericSetItem:

• mutSeqSliceOp: template genGenericSetItem(Arr, Arr2)

gen_getmembers_static:

• members: template gen_getmembers_static(prag): untyped

genInfos:

• geninfos: template genInfos(S; cache_tag_val)

GenIntEnumMeth:

• intEnum: template GenIntEnumMeth(Self: typedesc; Int = int; genObjMeth = true; genInit = false)

genIter:

• iterGen: macro genIter(def)

genNonGenericSetItem:

• mutSeqSliceOp: template genNonGenericSetItem(Arr, Arr2)

genPlatform:

• genplatform: template genPlatform(S)

GenPyEnumInit:

• enumType: template GenPyEnumInit(Self, Value: typedesc; sym)

GenPyEnumMeth:

• enumType: template GenPyEnumMeth(Self; Value: typedesc; genObjMeth = true; genInit = false; nameError = NameError; Str = string)

genrand_uint32:

• proc_dispatched: proc genrand_uint32(self: PyRandom): uint32
• proc_dispatched: template genrand_uint32(): uint32

genSubstitute:

• templateImpl: template genSubstitute(M; Key; sym; doExc)

genWithArg:

• constsUtils: template genWithArg(sym, v32, v64)

genWithBracket:

• constsUtils: template genWithBracket(sym, v32, v64)
• constsUtils: template genWithBracket(sym, v32, v64, Ret)

geOk:

• err: GammaError.geOk

geOverFlow:

• err: GammaError.geOverFlow

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: proc get[K, V](m: Mapping[K, V]; key: K): V
• collections: proc get[K, V](m: Mapping[K, V]; key: K; default: V): V

getatime:

• path: proc getatime[T](p: PathLike[T]): float

getChar:

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

getCharPtr:

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

getctime:

• path: proc getctime[T](p: PathLike[T]): float

getcwd:

• utils: proc getcwd(): PyStr

getcwdb:

• utils: proc getcwdb(): PyBytes

getdefaultencoding:

• sys: proc getdefaultencoding(): PyStr
• getencodings: proc getdefaultencoding(): string

getdoc:

• inspect: template getdoc(obj: untyped): PyStr
• n_inspect: macro getdoc(obj: typed): string

getdocNoDedentImpl:

• sourcegetters: proc getdocNoDedentImpl(obj: NimNode): string

getErrno:

• errnoUtils: proc getErrno(): cint

getfile:

• inspect: template getfile(obj: untyped): PyStr
• sourcegetters: macro getfile(obj: typed): string

getfilesystemencoding:

• sys: proc getfilesystemencoding(): PyStr
• getencodings: proc getfilesystemencoding(): string

GET_FLOAT_WORD:

• common: template GET_FLOAT_WORD(x: float32): uint32
• common: template GET_FLOAT_WORD(word: var uint32; x: float32)

getFrameOrNil:

• frames: proc getFrameOrNil(): PFrame
• frames: proc getFrameOrNil(up: int): PFrame

get_handle_inheritable:

• inheritable: proc get_handle_inheritable(handle: int): bool

get_handler:

• state: proc get_handler(i: cint): PySigHandler

GetIdent:

• substituteImpl: type GetIdent

get_identifiers:

• n_string: proc get_identifiers(templ: Template): seq[string]
• string: proc get_identifiers(templ: Template): PyList[PyStr]

getIdentifiers:

• substituteImpl: iterator getIdentifiers(templ: string): string

get_identifiersMayDup:

• templateImpl: iterator get_identifiersMayDup(templ: Template): string

get_inheritable:

• inheritable: proc get_inheritable(fd: int): bool

getitimer:

• unixs: proc getitimer(which: int): tuple[delay, interval: float]

getline:

• sourcegetters: macro getline(obj: typed): int

getLowWord:

• common: template getLowWord(x: float32): uint16
• common: template getLowWord(x: float64): uint32

getMaxChar:

• codecs: proc getMaxChar[C](): C

getmembers:

• inspect: iterator getmembers[T](obj: T): GetMemberType
• inspect: iterator getmembers[T](obj: T; predict: GetMembersPredict): GetMemberType
• inspect: template getmembers(obj): PyList
• inspect: template getmembers(obj; predict: GetMembersPredict): PyList
• members: iterator getmembers[T](obj: var T): GetMemberType
• members: iterator getmembers[T](obj: var T; predict: GetMembersPredict): GetMemberType
• members: template getmembers(obj): seq
• members: template getmembers(obj; predict: GetMembersPredict): seq

getmembersImpl:

• members: template getmembersImpl[R](obj; predict; initResult): R

GetMembersPredict:

• members: type GetMembersPredict

getmembers_static:

• inspect: template getmembers_static(obj): untyped
• inspect: template getmembers_static(obj; predict: GetMembersPredict): untyped
• members: template getmembers_static(obj): untyped
• members: template getmembers_static(obj; predict: GetMembersPredict): untyped

GetMembersType:

• members: type GetMembersType

GetMemberType:

• members: type GetMemberType

getmodulename:

• inspect: template getmodulename(obj: PyStr): PyStr
• n_inspect: proc getmodulename(obj: string): string

getmodulenameImpl:

• modulename: proc getmodulenameImpl(path: string; res: var string): bool

getmstate:

• types: proc getmstate(self: PyRandom): var PyRandomState

getmtime:

• path: proc getmtime[T](p: PathLike[T]): float

getOrDefault:

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

getpagesize:

• funcs: proc getpagesize(): int

getpid:

• get_id: proc getpid(): int

getPlatform:

• genplatform: proc getPlatform(): string

getPtr:

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

getrandbits:

• proc_others: method getrandbits(self: PyRandom; k: int): int
• proc_others: template getrandbits(k: int): int

getrandom:

• os: proc getrandom(size: int; flags = 0): PyBytes

getrlimit:

• funcs: proc getrlimit(resource: int): py_rlimit

getrusage:

• funcs: proc getrusage(who: int): struct_rusage

getsignal:

• signal_util: proc getsignal(signalnum: int): PySigHandler

getsize:

• path: proc getsize[T](filename: PathLike[T]): int

getsizeof:

• sizes: template getsizeof(x): int
• sizes: template getsizeof(x; default: int): int

getsource:

• inspect: template getsource(obj: untyped): PyStr
• sourcegetters: macro getsource(obj: typed): string

getsourcefile:

• inspect: template getsourcefile(obj: untyped): PyStr
• sourcegetters: template getsourcefile(obj: typed): string

getsourcelines:

• inspect: macro getsourcelines(obj: typed): (PyList[string], int)
• n_inspect: macro getsourcelines(obj: typed): (seq[string], int)

getsourcelinesImpl:

• sourcegetters: template getsourcelinesImpl(obj: NimNode; splitlines): untyped

getstate:

• proc_dispatched: proc getstate(): PyRandomState
• types: method getstate(self: PyRandom): PyRandomState

get_terminal_size:

• term: proc get_terminal_size(fd = STDOUT_FILENO): terminal_size

geUnderFlow:

• err: GammaError.geUnderFlow

geZeroCantDetSign:

• err: GammaError.geZeroCantDetSign

gmtime:

• struct_time_funcs: proc gmtime(): struct_time
• struct_time_funcs: proc gmtime(secs: float): struct_time
• struct_time_funcs: proc gmtime(secs: int64): struct_time

gmtime_r:

• struct_tm_meth: proc gmtime_r(t: var time_t; tm: var Tm): ptr Tm

gRand:

• gstate: template gRand(): untyped

gRandom:

• gstate: var gRandom

guass:

• proc_dispatched: proc guass(self: PyRandom; mu = 0.0; sigma = 1.0): float
• proc_dispatched: template guass(mu = 0.0; sigma = 1.0): float

handle:

• substituteImpl: template handle[M](s: SubsCfg; formatstr: string; m: M; lookup)

Handlers:

• enums: proc Handlers(value: Handlers): Handlers
• enums: proc Handlers(value: int): Handlers
• enums_decl: type Handlers
• state: template Handlers(): untyped

hardlink_to:

• pathlib: proc hardlink_to(self: Path; target: string | Path)

hasBug:

• abs: const hasBug
• nansign: const hasBug
• newUninit: const hasBug

hasChar:

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

hash:

• set_decl: proc hash[H](self: PyFrozenSet[H]): int
• hashImpl: proc hash(self: datetime): int
• decl: proc hash(self: timedelta): int
• decl: proc hash(self: timezone): int
• types: proc hash(self: Path): int
• enums: proc hash(self: Signals): Hash
• enums: proc hash(self: Handlers): Hash
• enums: proc hash(self: Sigmasks): Hash

hashcode:

• inner_decl: proc hashcode(self: datetime): int

hashcode=:

• inner_decl: proc hashcode=(self: datetime; h: int)

HAVE_GCC_ASM_FOR_MC68881:

• floats: const HAVE_GCC_ASM_FOR_MC68881

HAVE_GCC_ASM_FOR_X87:

• floats: const HAVE_GCC_ASM_FOR_X87

HAVE_GETPAGESIZE:

• resource: const HAVE_GETPAGESIZE

have_getrandom:

• bootstrap_hash: const have_getrandom

have_getrandom_syscall:

• bootstrap_hash: const have_getrandom_syscall

HAVE_MBRTOWC:

• wchar_t: const HAVE_MBRTOWC

HAVE_PRLIMIT:

• resource: const HAVE_PRLIMIT

HAVE_PY_SET_53BIT_PRECISION:

• floats: template HAVE_PY_SET_53BIT_PRECISION(): bool

HAVE_SIGACTION:

• c_syms: const HAVE_SIGACTION

HAVE_STRSIGNAL:

• signal: const HAVE_STRSIGNAL

HAVE_STRUCT_TM_TM_ZONE:

• struct_tm_decl: const HAVE_STRUCT_TM_TM_ZONE

HAVE_SYSCONF_PAGE_SIZE:

• resource: const HAVE_SYSCONF_PAGE_SIZE

hex:

• strbltins: proc hex(a`gensym16: SomeInteger): PyStr

hexdigits:

• string: const hexdigits
• consts: const hexdigits

hexversion:

• n_sys: const hexversion
• sys: const hexversion

HIGH:

• indices: const HIGH

HighWordFracBits:

• consts: template HighWordFracBits[F](): untyped

home:

• meth: proc home(_: typedesc[Path]): Path

hour:

• inner_decl: proc hour(self: datetime): int

hugeF:

• expm1: template hugeF[F](): untyped

hypot:

• n_math: proc hypot[I: SomeFloat](x, y: I): I
• n_math: proc hypot[I: SomeFloat](x, y, z: I; args: varargs[I]): I

iadd:

• ops: proc iadd(t1: var PyTime; t2: PyTime): bool

ifInvalidOnVcc:

• chk_util: template ifInvalidOnVcc(signalnum: cint; handleExc)

impExp:

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

impJsOrC:

• platformUtils: template impJsOrC(sym, cfloatSym, argSym)

implementation:

• n_sys: const implementation
• sys: const implementation

inc:

• cstring_ptr_op: template inc(s: cstring; i = 1)
• ptr_op: template inc[T](s: ptr T; i = 1)
• wchar_t: template inc[I](p: var ptr wchar_t; i: I = 1)

incl:

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

INCOMPLETE_CHARACTER:

• wchar_t: const INCOMPLETE_CHARACTER

index:

• pyrange: proc index[T](r: PyRange[T]; x: T): int
• collections: proc index[T](s: Sequence[T]; x: T; start = 0; stop = -1): 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
• proc_others: proc index[I: Ordinal](x: I): 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)

inf:

• n_math: const inf

init:

• oserror_new: proc init[E: PyOSError](self: ref E; args: OSErrorArgs)

init32FloatView:

• float_view: template init32FloatView(FLOAT32_VIEW, UINT16_VIEW)

init64FloatView:

• float_view: template init64FloatView(FLOAT64_VIEW, UINT32_VIEW)

initBufAsPy:

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

initChainMap:

• n_chainmap: proc initChainMap[K, V](a, b: Table[K, V]): ChainMap[K, V]

initDocTable:

• doc_utils: proc initDocTable(moduleDoc: string; init: openArray[(string, string)]): DocTable

initErrorcodeMap:

• errorcodeInit: macro initErrorcodeMap(K, V; res: untyped; initFunc: typed)

initIgnoreExcHandle:

• substituteImpl: proc initIgnoreExcHandle(): ExcHandle

initNCodecInfo:

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

initPySignal:

• state: proc initPySignal(install_signal_handlers: bool)

initRaisesExcHandle:

• substituteImpl: proc initRaisesExcHandle(): ExcHandle

initStructTime:

• types: template initStructTime(): struct_time
• types: template initStructTime(year, mon, mday, hour, min, sec, wday, yday, isdst, zone, gmtoff): struct_time

initSubsCfg:

• substituteImpl: proc initSubsCfg(excHandle = initRaisesExcHandle(); delimiter = Delimiter): SubsCfg

initTm:

• struct_tm_decl: proc initTm(): Tm
• struct_tm_decl: template initTm(tm: var Tm)

initVal_with_handle_signal:

• handle_signal: template initVal_with_handle_signal[R](res: var R; resExpr)

InJs:

• defined_macros: const InJs

inMicroseconds:

• decl: proc inMicroseconds(self: timedelta): int64

insert:

• list: proc insert[T](self: var PyList[T]; idx: int; x: T)

insort:

• n_bisect: proc insort[T; K](a: var seq[T]; x: K; lo = 0; hi = len(a); key: Key[T, K])
• n_bisect: proc insort[T](a: var seq[T]; x: T; lo = 0; hi = len(a))

insort_left:

• n_bisect: proc insort_left[T; K](a: var seq[T]; x: K; lo = 0; hi = len(a); key: Key[T, K])
• n_bisect: proc insort_left[T](a: var seq[T]; x: T; lo = 0; hi = len(a))

insort_right:

• n_bisect: proc insort_right[T; K](a: var seq[T]; x: K; lo = 0; hi = len(a); key: Key[T, K])
• n_bisect: proc insort_right[T](a: var seq[T]; x: T; lo = 0; hi = len(a))

inspect.cleandoc:

• inspect_cleandoc: proc inspect.cleandoc(doc: openArray[char]): string

int_AsMode_t:

• isXImpl: proc int_AsMode_t(value: int): Mode

InterruptedError:

• types: object InterruptedError

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

isabs:

• path: proc isabs(s: PathLike): bool

is_absolute:

• meth: proc is_absolute(self: Path): bool

IsADirectoryError:

• types: object IsADirectoryError

isalnum:

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

isalpha:

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

isascii:

• 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

isawaitable:

• inspect: template isawaitable(obj): bool
• isX: template isawaitable(obj: typed): bool

isbuiltin:

• isX: macro isbuiltin(obj: typed): bool

isclass:

• isX: macro isclass(obj: typed): bool

isclose:

• n_math: proc isclose(a, b: SomeFloat; rel_tol = 1e-9; abs_tol = 0.0): bool

IS_CONTINUATION_BYTE:

• codecs: template IS_CONTINUATION_BYTE(ch: untyped): untyped

iscoroutine:

• isX: macro iscoroutine(obj: typed): bool

iscoroutinefunction:

• inspect: template iscoroutinefunction(obj): bool
• isX: macro iscoroutinefunction(obj: typed): bool

isdigit:

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

isdir:

• path: proc isdir(s: PathLike): bool

is_dir:

• scandirImpl: proc is_dir(self: DirEntry): bool
• scandirImpl: proc is_dir(self: DirEntry; follow_symlinks: bool): bool
• meth: proc is_dir(self: Path): bool

isdisjoint:

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

isErr:

• errnoUtils: template isErr(E: untyped): bool

isErr0:

• errnoUtils: template isErr0(): bool

isfile:

• path: proc isfile(s: PathLike): bool

is_file:

• scandirImpl: proc is_file(self: DirEntry): bool
• scandirImpl: proc is_file(self: DirEntry; follow_symlinks: bool): bool
• meth: proc is_file(self: Path): bool

isfinite:

• isX: proc isfinite(x: SomeFloat): bool

isfold:

• inner_decl: proc isfold(self: datetime): bool

isframe:

• isX: template isframe(obj: typed): bool

isfunction:

• isX: macro isfunction(obj: typed): bool

isinf:

• isX: proc isinf(x: SomeFloat): bool

isInfinite:

• assertIsInfinite: template isInfinite(f: SomeFloat): bool

islink:

• path: proc islink(s: PathLike): bool

isLittleEndian:

• assertIsLittleEndian: proc isLittleEndian(): bool

islower:

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

ismethod:

• isX: macro ismethod(obj: typed): bool

ismodule:

• isX: macro ismodule(obj: typed): bool

isocalendar:

• getter_of_date: proc isocalendar(self: datetime): YWD

isoformat:

• datetime: proc isoformat(self: datetime; sep: StringLike = 'T'; timespec = "auto"): PyStr
• isoformat: proc isoformat(self: datetime; sep: char | string; timespec: IsoFormatTimespec): string
• isoformat: proc isoformat(self: datetime; sep: char | string = "T"; timespec = "auto"): string

IsoFormatTimespec:

• isoformat: enum IsoFormatTimespec

iso_to_ymd:

• calendar_utils: proc iso_to_ymd(iso: YWD; ymd: var YMD)

iso_week1_monday:

• calendar_utils: proc iso_week1_monday(year: int): int

isoweekday:

• getter_of_date: proc isoweekday(self: datetime): int

isqrt:

• math: proc isqrt[I: SomeInteger](x: I): int
• n_math: proc isqrt(n: Natural): int
• n_math: proc isqrt[T: SomeFloat](x: T): int

isqrtPositive:

• n_math: proc isqrtPositive(n: Positive): int

is_relative_to:

• meth: proc is_relative_to(self: Path; other: Path): bool
• meth: proc is_relative_to(self: Path; other: string): bool

ISSPACE:

• 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

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

is_symlink:

• scandirImpl: proc is_symlink(self: DirEntry): bool
• meth: proc is_symlink(self: Path): bool

isTimeDeltaNone:

• decl: proc isTimeDeltaNone(self: timedelta): bool

istitle:

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

istitleImpl:

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

istraceback:

• isX: template istraceback(obj: typed): bool

isTzNone:

• decl: proc isTzNone(self: tzinfo): bool

isupper:

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

isUtcZone:

• types: template isUtcZone(st: struct_time): bool

is_valid:

• string: proc is_valid(templ: Template): bool

isValid:

• substituteImpl: proc isValid(templ: string): bool

is_valid:

• templateImpl: proc is_valid(templ: Template): bool

is_valid_wide_char:

• wchar_t: proc is_valid_wide_char(ch: wchar_t): 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: iterator items[T](x: Enumerate[T]): T
• iters: iterator items[T](x: Filter[T]): T
• iters: iterator items[T](x: Map[T]): T
• iters: iterator items[T](x: Reversed[T]): T
• iters: iterator items[T](x: Zip[T]): T
• 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: iterator items[K, V](m: Mapping[K, V]): (K, V)
• bytesimpl: iterator items(self: PyBytes): int
• strimpl: iterator items(self: PyStr): PyStr
• wchar_utils: iterator items(s): wchar_t
• scandirImpl: iterator items[T](scandirIter: ScandirIterator[T]): DirEntry[T]
• enums: iterator items(cls: cls:type): Signals
• enums: iterator items(cls: cls:type): Handlers
• enums: iterator items(cls: cls:type): Sigmasks

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]
• generators: template iter[T; S; R](self: Generator[T, S, R]): Iterator[T]

Iterable:

• iters: type Iterable

Iterator:

• iters: type Iterator

iterdir:

• meth: proc iterdir(self: Path): IterDirGenerator
• meth: iterator iterdir(self: Path): Path

ItimerError:

• unixs: object ItimerError

ITIMER_PROF:

• c_syms: let ITIMER_PROF
• enums: let ITIMER_PROF

ITIMER_REAL:

• c_syms: let ITIMER_REAL
• enums: let ITIMER_REAL

ItimerVal:

• unixs: object ItimerVal

ITIMER_VIRTUAL:

• c_syms: let ITIMER_VIRTUAL
• enums: let ITIMER_VIRTUAL

join:

• 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
• path: proc join[T](a, b: PathLike[T]): T
• path: proc join[T](a, b, c: PathLike[T]; ps: varargs[PathLike[T]]): T

joinpath:

• pathlib: proc joinpath[P: PathLike](self: Path; pathsegments: varargs[P]): Path
• meth: proc joinpath[P: string](self: Path; pathsegments: varargs[P]): Path

JsBigInt64Option:

• utils: const JsBigInt64Option

justLessThanOne:

• justLessThanOneConst: const justLessThanOne

Key:

• n_bisect: type Key

KeyboardInterrupt:

• rterr: object KeyboardInterrupt

keys:

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

LC_ALL:

• localeutils: let LC_ALL

LC_CTYPE:

• localeutils: let LC_CTYPE

lcm:

• n_math: proc lcm[I: SomeInteger](x, y: I): I
• n_math: proc lcm[I: SomeInteger](x, y, z: I; args: varargs[I]): I

ldexp:

• math: proc ldexp(x: SomeFloat; i: int): float
• ldexp: proc ldexp[F: SomeFloat](frac: F; exp: int): F
• n_math: proc ldexp[F: SomeFloat](x: F; i: int): F
• n_math: proc ldexp[F: SomeFloat](x: F; i: int; exc: var ref Exception): F

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
• bytesimpl: proc len(self: PyBytes): int
• strimpl: proc len(self: PyStr): int
• strimpl: proc len(c: char): int
• wchar_utils: proc len(s): int
• enums: proc len(cls: cls:type): int
• enums: proc len(cls: cls:type): int
• enums: proc len(cls: cls:type): int

lgamma:

• math: proc lgamma[F: SomeFloat](x: F): F
• lgamma: proc lgamma[F: SomeFloat](x: F): F
• lgamma: proc lgamma[F: SomeFloat](x: F; res: var F): GammaError
• n_math: proc lgamma[F: SomeFloat](x: F): F

linesep:

• consts: let linesep

link:

• links: proc link[T](src, dst: PathLike[T])

list:

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

listdir:

• listdirx: proc listdir[T](p: PathLike[T] = "."): PyList[T]

ljust:

• 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

ln2_hi:

• common: const ln2_hi

ln2_lo:

• common: const ln2_lo

local:

• to_seconds_utils: proc local(u: BiggestInt): BiggestInt

LocaleEncoding:

• io: const LocaleEncoding

localtime:

• struct_time_funcs: proc localtime(): struct_time
• struct_time_funcs: proc localtime(secs: float): struct_time
• struct_time_funcs: proc localtime(secs: int64): struct_time

localtime_r:

• struct_tm_meth: proc localtime_r(t: var time_t; tm: var Tm): ptr Tm

local_to_seconds:

• to_seconds_utils: proc local_to_seconds(year, month, day, hour, minute, second: int; fold: int): BiggestInt

log:

• math: proc log[F: SomeFloat](x: F): F
• math: proc log[F: SomeFloat](x, base: F): F
• n_math: proc log[F: SomeFloat](x: F): F
• n_math: proc log[F: SomeFloat](x, base: F): F

log10:

• math: proc log10[F: SomeFloat](x: F): F
• n_math: proc log10[F: SomeFloat](x: F): F

log1p:

• math: proc log1p[F: SomeFloat](x: F): F
• log1p: proc log1p[F: SomeFloat](x: F): F
• expm1_log1p: proc log1p[F: SomeFloat](x: F): F

log2:

• math: proc log2[F: SomeFloat](x: F): F
• n_math: proc log2[F: SomeFloat](x: F): F

lognormalvariate:

• proc_others: proc lognormalvariate(self: PyRandom; mu, sigma: float): float
• proc_others: template lognormalvariate(mu, sigma: float): float

long:

• types: type long

LookupError:

• lkuperr: object LookupError

LOW:

• indices: const LOW

lower:

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

lseek:

• lseek: proc lseek(fd: int; position: int64; whence: int): int64

lstrip:

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

Major:

• versionInfo: const Major

makedirs:

• utils: proc makedirs[T](d: PathLike[T]; mode = 0o000000000777; exists_ok = false)

makeIterable:

• iterGen: template makeIterable(Typ)

maketrans:

• 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

MantissaDigits:

• consts: template MantissaDigits[F](): untyped

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
• iters: macro map(function: proc; iterable: typed; iterables: varargs[typed]): Map

mapIterBodyImpl:

• mapMacro: proc mapIterBodyImpl(f: NimNode; iterables: NimNode; res = genSym(nskVar, "res")): NimNode

mapPathLike:

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

Mapping:

• collections: type Mapping

mapRaiseGammaErr:

• err: proc mapRaiseGammaErr(err: GammaError)

markcoroutinefunction:

• inspect: template markcoroutinefunction(obj): untyped
• isX: macro markcoroutinefunction[T](obj: T): T

math_is_error:

• n_math: proc math_is_error(x: SomeFloat; exc: var ref Exception): bool

max:

• pyrange: proc max[T](x: PyRange[T]): T
• consts: proc max(_: typedesc[datetime]): datetime
• meth: proc max(_: _`gensym1610612820:type): timedelta

MAX_EXPONENT:

• consts: template MAX_EXPONENT[F](_: typedesc[F]): F

max_fold_seconds:

• to_seconds_utils: let max_fold_seconds

MAX_GAMMA_X:

• gammaXRange: template MAX_GAMMA_X[F](_: typedesc[F]): F

maxSafeInteger:

• consts: template maxSafeInteger[F](_: typedesc[F]): F

maxsize:

• n_sys: const maxsize
• sys: const maxsize

MAX_STIRLING:

• gamma: template MAX_STIRLING[F](_: typedesc[F]): F

MAX_SUBNORMAL_EXPONENT:

• consts: template MAX_SUBNORMAL_EXPONENT[F](_: typedesc[F]): F

MAX_UNICODE_val:

• wchar_t: const MAX_UNICODE_val

MaxWStrLen:

• utf8_codec: const MaxWStrLen

MAXYEAR:

• inner_consts: const MAXYEAR

mayZeroDefault:

• n_itertools: template mayZeroDefault[T](t: typedesc[T]): T

mbstate_t:

• wchar_t: object mbstate_t

microsecond:

• inner_decl: proc microsecond(self: datetime): int

microseconds:

• getter: proc microseconds(self: timedelta): int64

microsecondsImpl:

• getter: proc microsecondsImpl(parts: DurationParts): int64

min:

• pyrange: proc min[T](x: PyRange[T]): T
• consts: proc min(_: typedesc[datetime]): datetime
• meth: proc min(_: _`gensym1610612816:type): timedelta

MIN_GAMMA_X:

• gammaXRange: template MIN_GAMMA_X[F](_: typedesc[F]): F

Minor:

• versionInfo: const Minor

MIN_SUBNORMAL_EXPONENT:

• consts: template MIN_SUBNORMAL_EXPONENT[F](_: typedesc[F]): F

minute:

• inner_decl: proc minute(self: datetime): int

MINYEAR:

• inner_consts: const MINYEAR

mitems:

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

mixinOrderOnFields:

• macro_utils: macro mixinOrderOnFields(lhs, rhs: typed; cmpOp; cmpStragy: static[CmpStragy] = csEq): bool

mkdir:

• mkrmdir: proc mkdir(p: PathLike; mode = 0o000000000777)
• mkrmdir: proc mkdir(p: PathLike; mode = 0o000000000777; dir_fd: int)
• pathlib: proc mkdir(self: Path; mode = 0o000000000777; parents = false; exist_ok = false)

mkdirParentsExistsOk:

• meth: proc mkdirParentsExistsOk(self: Path)

mktime:

• struct_time_funcs: proc mktime(t: struct_time): float
• struct_time_funcs: proc mktime(tup: struct_time_tuple): typeof(mktime do: bind struct_time struct_time(tm_year: 1900, tm_mon: 1, tm_mday: 1, tm_yday: 1, tm_isdst: -1))

modf:

• n_math: proc modf[F: SomeFloat](x: F): tuple[intpart: F, floatpart: F]

monotonic:

• measures: proc monotonic(): float

monotonic_ns:

• measures: proc monotonic_ns(): int64

monotonicRaw:

• monotonic: proc monotonicRaw(res: var PyTime): bool

month:

• inner_decl: proc month(self: datetime): int
• struct_tm_decl: proc month(tm: Tm): int

msg:

• signals: proc msg(self: StopIteration): string
• signals: proc msg(self: StopIterationT): string

MS_TO_NS:

• units: const MS_TO_NS

MS_TO_US:

• units: const MS_TO_US

MS_WINDOWS:

• defined_macros: const MS_WINDOWS

ms_windows:

• defined_macros: const ms_windows

MutableSequence:

• collections: type MutableSequence

name:

• consts: const name
• pathlib: proc name(self: Path): PyStr
• segments: proc name(self: Path): string
• enums: proc name(self: Signals): string
• enums: proc name(self: Handlers): string
• enums: proc name(self: Sigmasks): string

NameError:

• simperr: object NameError

nan:

• n_math: const nan

NCodecInfo:

• ncodec: object NCodecInfo

newBlockingIOError:

• init: proc newBlockingIOError(myerrno: cint; strerr: string; filename = 0; winerror: cint = 0; filename2 = ""): ref PyOSError

newDatetime:

• inner_decl: proc newDatetime(dt: DateTime; tzinfo: tzinfo = nil; isfold = false): datetime
• inner_decl: proc newDatetime(self: datetime; tzinfo: tzinfo = self.tzinfo; isfold = self.isfold): datetime

newLoop:

• macroutils: proc newLoop(body: NimNode): NimNode

newNoEncTextIO:

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

newNullaryLambdaIter:

• macroutils: proc newNullaryLambdaIter(body: NimNode; resType = ident"auto"): NimNode

newPyDict:

• dict_decl: proc newPyDict[K, V](x: int): PyDict[K, V]
• dict_decl: proc newPyDict[K, V](x: openArray[(K, V)] = []): PyDict[K, V]

newPyDictImpl:

• dict_decl: template newPyDictImpl[K, V](x: int): untyped
• dict_decl: template newPyDictImpl[K, V](x: openArray[(K, V)] = []): 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(a: sink openArray[char]): PyList[char]
• list_decl: proc newPyList(a: sink openArray[float]): PyList[float]
• list_decl: proc newPyList(a: sink openArray[int]): PyList[int]
• list_decl: proc newPyList[T](a: sink openArray[T]): PyList[T]
• list_decl: proc newPyList[T](s: sink seq[T]): PyList[T]

newPyListOfCap:

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

newPyOSError:

• init: proc newPyOSError(myerrno: cint; strerr: string; filename = ""; winerror: cint = 0; filename2 = ""): ref PyOSError

newPySet:

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

newPyTimezone:

• decl: proc newPyTimezone(offset: timedelta): timezone
• decl: proc newPyTimezone(offset: timedelta; name: string): timezone

newStopIteration:

• signals: proc newStopIteration(): ref StopIteration
• signals: proc newStopIteration[T](value: T): ref StopIterationT[T]

newTimedelta:

• decl: proc newTimedelta(dur: Duration): timedelta
• decl: proc newTimedelta(days, seconds, microseconds: int; normalize = true): timedelta

newTuple:

• macroutils: proc newTuple(): NimNode

newUnicodeDecodeError:

• unicode_err: proc newUnicodeDecodeError(codec: string; src: char; start, stop: int; reason: string): ref UnicodeDecodeError
• unicode_err: proc newUnicodeDecodeError(codec: string; src: string; start, stop: int; reason: string): ref UnicodeDecodeError

newZoneCStr:

• zonename_utils: proc newZoneCStr(tm: var Tm): cstring

next:

• iter_next: proc next[T](self: PyIterator[T]): T
• generators: proc next[T; R](self: Generator[T, NoneType, R]): T

nextafter:

• math: proc nextafter[F: SomeFloat](x, y: F): F
• math: proc nextafter[F: SomeFloat](x, y: F; steps: int | uint64): F
• nextafter_step: proc nextafter(x, y: float; steps: int): float
• nextafter_step: proc nextafter(x, y: float; usteps: uint64): float
• nextafter_ulp: proc nextafter[F: SomeFloat](x, y: F): F
• nextafter_ulp: proc nextafter[F: SomeFloat](x, y: F; steps: int | uint64): F
• nextafter: proc nextafter[F](x, y: F): F
• nextafter_step: proc nextafter(x, y: float; usteps: uint64): float

nextImpl:

• iter_next: proc nextImpl[T](self: PyIterator[T]): Option[T]
• iter_next: proc nextImpl[T](self: PyIterator[T]; res: var T): bool

n_frexp:

• frexp: proc n_frexp[F: SomeFloat](x: F): (F, int)
• frexp: proc n_frexp[F: SomeFloat](x: F; e: var int): F

nimArrayAsList:

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

NimSigHandler:

• handler_types: type NimSigHandler

NimVersionTuple:

• utils: const NimVersionTuple

Ninf:

• consts: const Ninf

n_ldexp:

• ldexp: proc n_ldexp[F: SomeFloat](x: F; i: int): F

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

noInitVarDecl:

• macroutils: proc noInitVarDecl(name, Type: NimNode): NimNode

noJsBackend:

• backendMark: template noJsBackend(def)

None:

• noneType: const None

noneToTzInfo:

• datetime: converter noneToTzInfo(_: NoneType): tzinfo

NoneType:

• noneType: type NoneType

noNimsBackend:

• backendMark: template noNimsBackend(def)

normalize:

• normalize: proc normalize[F: SomeFloat](x: F): (F, int)

normalvariate:

• proc_others: proc normalvariate(self: PyRandom; mu = 0.0; sigma = 1.0): float
• proc_others: template normalvariate(mu = 0.0; sigma = 1.0): float

norm_maxsplit:

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

normpath:

• path: proc normpath[T](s: PathLike[T]): T

NotADirectoryError:

• types: object NotADirectoryError

NotImplDirectives:

• nstrfptime: const NotImplDirectives

NotImplementedError:

• rterr: object NotImplementedError

notImplErr:

• pyerr: template notImplErr(meth)

now:

• statics: proc now(_: _`gensym1744830482:type; tzinfo: tzinfo = TzNone): datetime

noWeirdBackend:

• backendMark: template noWeirdBackend(def)

noWeirdTarget:

• oserr: template noWeirdTarget(def)

nPyTime_gmtime:

• pytime: proc nPyTime_gmtime(t: time_t; tm: var Tm)

nPyTime_localtime:

• pytime: proc nPyTime_localtime(t: time_t; tm: var Tm)

nPyTime_ObjectToTimeval:

• pytime: proc nPyTime_ObjectToTimeval(obj: Timestamp; sec: var time_t; usec: var long; round: PyTime_round_t)

NSIG:

• n_signal: let NSIG

NS_TO_100NS:

• units: const NS_TO_100NS

NS_TO_MS:

• units: const NS_TO_MS

NS_TO_US:

• units: const NS_TO_US

NsUnit:

• utime: type NsUnit

nTime_gmtime:

• time_utils: proc nTime_gmtime(t: time_t): Tm

nTime_localtime:

• time_utils: proc nTime_localtime(t: time_t): Tm

O_APPEND:

• consts: let O_APPEND

O_ASYNC:

• os_consts: const O_ASYNC

O_CLOEXEC:

• consts: let O_CLOEXEC

O_CREAT:

• consts: let O_CREAT

oct:

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

octdigits:

• string: const octdigits
• consts: const octdigits

O_DIRECT:

• os_consts: const O_DIRECT

O_DIRECTORY:

• os_consts: const O_DIRECTORY

O_DSYNC:

• consts: let O_DSYNC

O_EXCL:

• consts: let O_EXCL

offset:

• decl: proc offset(self: timezone): timedelta

O_NDELAY:

• consts: let O_NDELAY

OnErrorCb:

• walkImpl: type OnErrorCb

O_NOATIME:

• os_consts: const O_NOATIME

O_NOCTTY:

• consts: let O_NOCTTY

O_NOFOLLOW:

• os_consts: const O_NOFOLLOW

O_NONBLOCK:

• consts: let O_NONBLOCK

O_PATH:

• os_consts: const O_PATH

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
• pathlib: template open(self: Path; mode: StringLike = "r"; buffering = -1; encoding = DefEncoding; errors = DefErrors; newline = DefNewLine): untyped
• meth: proc open(self: Path; mode: FileMode): File

openarray_Check:

• niter_types: template openarray_Check(x): bool

OpenarrayOrNimIter:

• niter_types: type OpenarrayOrNimIter

ord:

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

ord1:

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

orderOnFields:

• macro_utils: macro orderOnFields[T](a, b: T; cmpOp): bool

O_RDONLY:

• consts: let O_RDONLY

ord_to_ymd:

• calendar_utils: proc ord_to_ymd(ordinal: int; result: var YMD)

O_RDWR:

• consts: let O_RDWR

orig_argv:

• n_sys: var orig_argv
• sys: var orig_argv

O_RSYNC:

• consts: let O_RSYNC

OSErrorArgs:

• oserror_new: tuple OSErrorArgs

osErrorMsgWithPath:

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

OSError_new:

• oserror_new: proc OSError_new[E: PyOSError](useWinError: bool; myerrno: cint; strerr: string; filename: string | int = ""; winerror: cint = 0; filename2 = ""; fillMsg: static[bool] = true): ref PyOSError

oserror_use_init:

• oserror_new: template oserror_use_init[E: PyOSError](self): bool

O_SYNC:

• consts: let O_SYNC

o_threshold:

• expm1: template o_threshold[F](): untyped

O_TMPFILE:

• os_consts: const O_TMPFILE

O_TRUNC:

• consts: let O_TRUNC

O_WRONLY:

• consts: let O_WRONLY

p1evl:

• polevl: proc p1evl[F](x: F; coef: openArray[F]; N = coef.high - 1): F

pairs:

• list_decl: iterator pairs[T](self: PyList[T]): (int, T)

pardir:

• consts: let pardir

parent:

• segments: proc parent(self: Path): Path

parents:

• segments: proc parents(self: Path): seq[Path]
• segments: iterator parents(self: Path): Path

paretovariate:

• proc_others: proc paretovariate(self: PyRandom; alpha: float): float
• proc_others: template paretovariate(alpha: float): float

partition:

• 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]

parts:

• pathlib: proc parts(self: Path): PyList[PyStr]
• segments: proc parts(self: Path): seq[string]
• segments: iterator parts(self: Path): string

Patch:

• versionInfo: const Patch

Path:

• pathlib: proc Path[P: PathLike](pathsegments: varargs[P]): types.Path
• init: proc Path[P](pathsegments: varargs[P]): types.Path
• types: type Path

PathLike:

• io_abc: type PathLike

pathrepr:

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

pathsep:

• consts: let pathsep

pause:

• unixs: proc pause(): int

perf_counter:

• measures: proc perf_counter(): float

perf_counter_ns:

• measures: proc perf_counter_ns(): int64

perm:

• math: proc perm(n: int): int
• math: proc perm(n, k: int): int
• n_math: proc perm(n: int): int
• n_math: proc perm(n, k: Natural): int

PermissionError:

• types: object PermissionError

pi:

• n_math: const pi

pidfd_send_signal:

• signal_util: proc pidfd_send_signal(pid: int; sig: int; siginfo: struct_siginfo = nil; flags = 0)

Pinf:

• consts: const Pinf

platform:

• n_sys: const platform
• sys: const platform

platform.system:

• platformInfo: const platform.system

platform.version:

• platformInfo: proc platform.version(): string

platformAvail:

• platform_utils: template platformAvail(platform; def)

platformAvailWhen:

• platform_utils: template platformAvailWhen(platform; cond: bool; def)

platformNoJs:

• platform_utils: template platformNoJs(def)

platformUnavail:

• platform_utils: template platformUnavail(platform; def)

polevl:

• polevl: proc polevl[F](x: F; coef: openArray[F]; N = coef.high): F

polExpd:

• polevl: macro polExpd[F](x: F; coef: untyped): F

polExpd0:

• polevl: macro polExpd0[F](x: F; rcoef: untyped): F

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: proc pop[T](ms: MutableSequence[T]; index = -1): T

popitem:

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

pow:

• math: proc pow[F: SomeFloat](x, y: F): F
• n_math: proc pow[F: SomeFloat](x, y: F): F

prCeiling:

• types: PyTime_round_t.prCeiling

PreBreakCb:

• macroutils: type PreBreakCb

preferredGenIterResName:

• macroutils: const preferredGenIterResName

PREPARE_CAP:

• common: template PREPARE_CAP(maxcount): int

prepareROErrno:

• errnoUtils: template prepareROErrno()

prepareRWErrno:

• errnoUtils: template prepareRWErrno()

prFLoor:

• types: PyTime_round_t.prFLoor

prHalfEven:

• types: PyTime_round_t.prHalfEven

printable:

• string: const printable
• consts: const printable

prlimit:

• funcs: proc prlimit(pid: int; resource: int): py_rlimit
• funcs: proc prlimit(pid: int; resource: int; limits: py_rlimit_abc): py_rlimit

ProcessLookupError:

• types: object ProcessLookupError

process_time:

• measures: proc process_time(): float

prod:

• n_math: proc prod[T](iterable: Iterable[T]; start = 1.T): T

prRoundUp:

• types: PyTime_round_t.prRoundUp

prTimeout:

• types: const prTimeout

pthread_kill:

• unixs: proc pthread_kill(thread_id: uint; signalnum: int)

pthread_sigmask:

• signal: proc pthread_sigmask(how: int; mask: Sigset): PySet[int]
• unixs: proc pthread_sigmask(how: int; mask: Sigset): Set[int]

ptrdiff_t:

• ptr_types: type ptrdiff_t

punctuation:

• string: const punctuation
• consts: const punctuation

pyasciiImpl:

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

Py_atomic_load:

• pyatomic: template Py_atomic_load[T](obj: T): T

Py_atomic_load_ptr:

• pyatomic: template Py_atomic_load_ptr[T](obj: ptr T): T

Py_atomic_store:

• pyatomic: template Py_atomic_store[T](obj: T; value: T)

Py_atomic_store_ptr:

• pyatomic: template Py_atomic_store_ptr[T](obj: ptr T; value: T)

PyBool:

• pybool: type PyBool

pybool:

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

PyBytes:

• bytesimpl: type PyBytes

pybytes:

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

PyDatetime:

• inner_decl: type PyDatetime

PyDeadline_Get:

• deadline: proc PyDeadline_Get(deadline: PyTime): PyTime

PyDeadline_Init:

• deadline: proc PyDeadline_Init(timeout: PyTime): PyTime

Py_DecodeLocaleEx:

• fileutils: proc Py_DecodeLocaleEx(arg: cstring; wstr: var ptr wchar_t; wlen: ptr csize_t; reason: var cstring; current_locale: bool; errors: Py_error_handler): int

Py_DecodeUTF8Ex:

• utf8_codec: proc Py_DecodeUTF8Ex(orig_s: cstring; size: csize_t; wstr: var ptr wchar_t; wlen: ptr csize_t; reason: var cstring; errors: Py_error_handler): int

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)

PyErr_CheckSignals:

• c_api: proc PyErr_CheckSignals(): int

PyErr_CheckSignalsAndRaises:

• c_api: proc PyErr_CheckSignalsAndRaises()

Py_ERROR_BACKSLASHREPLACE:

• pycore_fileutils: Py_error_handler.Py_ERROR_BACKSLASHREPLACE

Py_error_handler:

• pycore_fileutils: enum Py_error_handler

Py_ERROR_IGNORE:

• pycore_fileutils: Py_error_handler.Py_ERROR_IGNORE

Py_ERROR_OTHER:

• pycore_fileutils: Py_error_handler.Py_ERROR_OTHER

Py_ERROR_REPLACE:

• pycore_fileutils: Py_error_handler.Py_ERROR_REPLACE

Py_ERROR_STRICT:

• pycore_fileutils: Py_error_handler.Py_ERROR_STRICT

Py_ERROR_SURROGATEESCAPE:

• pycore_fileutils: Py_error_handler.Py_ERROR_SURROGATEESCAPE

Py_ERROR_SURROGATEPASS:

• pycore_fileutils: Py_error_handler.Py_ERROR_SURROGATEPASS

Py_ERROR_UNKNOWN:

• pycore_fileutils: Py_error_handler.Py_ERROR_UNKNOWN

Py_ERROR_XMLCHARREFREPLACE:

• pycore_fileutils: Py_error_handler.Py_ERROR_XMLCHARREFREPLACE

Py_FORCE_UTF8_FS_ENCODING:

• force_ascii_utils: const Py_FORCE_UTF8_FS_ENCODING

Py_FORCE_UTF8_LOCALE:

• force_ascii_utils: const Py_FORCE_UTF8_LOCALE

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

Py_GetErrorHandler:

• pycore_fileutils: proc Py_GetErrorHandler(errors: string): Py_error_handler

Py_GetForceASCII:

• force_ascii_utils: proc Py_GetForceASCII(): bool

Py_GetLocaleEncoding:

• fileutils: proc Py_GetLocaleEncoding(): string

py_getrandom:

• bootstrap_hash: const py_getrandom

Py_IS_ALIGNED:

• codecs: template Py_IS_ALIGNED(p: cstring | ptr; a: typeof(ALIGNOF_SIZE_T)): bool

PyIterator:

• iter_next: type PyIterator

PyList:

• list_decl: type PyList

PyMajor:

• versionInfo: const PyMajor

py_math_isclose_impl:

• n_math: template py_math_isclose_impl(abs)

Py_mbrtowc:

• wchar_t: proc Py_mbrtowc(wc: PWc; src: cstring; n: csize_t; mbs: var mbstate_t): csize_t

Py_mbstowcs:

• wchar_t: proc Py_mbstowcs(dest: ptr wchar_t; src: cstring; n: csize_t): csize_t

PyMinor:

• versionInfo: const PyMinor

Py_normalize_encoding:

• encoding_norm: proc Py_normalize_encoding(encoding: string): string

Py_NSIG:

• signal: const Py_NSIG

PyOSError:

• init: proc PyOSError(myerrno: cint; strerr: string; filename = ""; winerror: cint = 0; filename2 = ""): ref PyOSError
• oserror_decl: object PyOSError

PyOS_getsig:

• signal: proc PyOS_getsig(sig: cint): CSigHandler

PyOS_setsig:

• signal: proc PyOS_setsig(sig: cint; handler: CSigHandler): CSigHandler

PyPatch:

• versionInfo: const PyPatch

PyRandom:

• types: type PyRandom

PyRandomState:

• types: type PyRandomState

PyRange:

• pyrange: type PyRange

PyReleaseLevel:

• versionInfo: const PyReleaseLevel

PyReleaseLevelEnum:

• versionInfo: enum PyReleaseLevelEnum

pyrepr:

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

pyreprbImpl:

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

pyreprImpl:

• reprImpl: proc pyreprImpl(s: string; escape127: static[bool] = false): string

Py_ResetForceASCII:

• force_ascii_utils: proc Py_ResetForceASCII()

py_rlimit:

• funcs: tuple py_rlimit

PySerial:

• versionInfo: const PySerial

pyset:

• set: proc pyset[H](): PySet[H]
• 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]

PySet:

• set_decl: type PySet

Py_SET_53BIT_PRECISION_END:

• floats: template Py_SET_53BIT_PRECISION_END()

Py_SET_53BIT_PRECISION_HEADER:

• floats: template Py_SET_53BIT_PRECISION_HEADER()

Py_SET_53BIT_PRECISION_START:

• floats: template Py_SET_53BIT_PRECISION_START()

Py_set_inheritable:

• inheritable: proc Py_set_inheritable(fd: int; inheritable: bool; atomic_flag_works: ptr int): int

pysetLit:

• set: macro pysetLit(lit): PySet

Py_SetLocaleFromEnv:

• envutils: proc Py_SetLocaleFromEnv(category: cint): cstring

PySigHandler:

• handler_types: type PySigHandler

PySignal_Fini:

• state: proc PySignal_Fini()

pysince:

• version: proc pysince[R](ver: static[float | MajorMinorVersion]; defExpr, elseExpr: R): R
• version: macro pysince(major, minor: static int; def)
• version: template pysince[R](ver: MajorMinorVersion; defExpr, elseExpr: R): R

PySlice:

• pyslice: type PySlice

PySlice1:

• pyslice: type PySlice1

PyStr:

• strimpl: type PyStr

PyTime:

• types: type PyTime

PyTime_round_t:

• types: enum PyTime_round_t

PY_TIME_T_MAX:

• time_t_decl: const PY_TIME_T_MAX

PY_TIME_T_MIN:

• time_t_decl: const PY_TIME_T_MIN

Py_UCS1:

• char_decl: type Py_UCS1

Py_UCS2:

• char_decl: type Py_UCS2

Py_UCS4:

• char_decl: type Py_UCS4

PyUnicode_DecodeLocale:

• locale_codec: proc PyUnicode_DecodeLocale(str: PyStrData; errors: string): string

Py_UNICODE_IS_SURROGATE:

• wchar_t: template Py_UNICODE_IS_SURROGATE(ch: wchar_t): bool

radians:

• n_math: proc radians[F: SomeFloat](x: F): F

raiseDomainErr:

• err: template raiseDomainErr()
• err: template raiseDomainErr(details: string)

raiseErrno:

• oserr: proc raiseErrno(errno = getErrno())

raiseErrnoT:

• oserr: proc raiseErrnoT[T: PyOSError](errno = getErrno())

raiseErrnoWithPath:

• oserr: proc raiseErrnoWithPath[T](p: PathLike[T]; errno = getErrno())

raiseExcWithPath:

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

raiseExcWithPath2:

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

raiseOsOrFileNotFoundError:

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

raiseRangeErr:

• err: template raiseRangeErr()
• err: template raiseRangeErr(details: string)

raise_signal:

• signal_util: proc raise_signal(signalnum: int)

raiseZipBound:

• zipMacro: proc raiseZipBound(ordLonger: int)

randbelow:

• proc_dispatched: proc randbelow[T: SomeInteger](self: PyRandom; n: T): T
• proc_dispatched: template randbelow[T: SomeInteger](n: T): T

randbytes:

• random: proc randbytes(self: PyRandom; n: int): PyBytes
• random: template randbytes(n: int): PyBytes
• proc_others: method randbytes(self: PyRandom; n: int): string
• proc_others: template randbytes(n: int): string

randint:

• proc_dispatched: proc randint[T: SomeInteger](self: PyRandom; a, b: T): T
• proc_dispatched: template randint[T: SomeInteger](a, b: T): T

random:

• proc_dispatched: method random(self: PyRandom): float
• proc_dispatched: template random(): float

Random:

• types: proc Random(): PyRandom
• types: proc Random(x: int64): PyRandom

randrange:

• proc_dispatched: proc randrange[T: SomeInteger](self: PyRandom; stop: T): T
• proc_dispatched: proc randrange[T: SomeInteger](self: PyRandom; start, stop: T): T
• proc_dispatched: template randrange[T: SomeInteger](stop: T): T
• proc_dispatched: template randrange[T: SomeInteger](start, stop: T): T
• proc_others: proc randrange[I: SomeInteger](self: PyRandom; istart, istop: I; istep: I): I
• proc_others: proc randrange[T; I: Indexable[T]](self: PyRandom; start, stop, step: I): T
• proc_others: template randrange[I: SomeInteger](istart, istop: I; istep: I): I
• proc_others: template randrange[T; I: Indexable[T]](start, stop, step: I): 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

rawCreateDir:

• mkrmdirImpl: proc rawCreateDir(dp: PathLike; mode = 0o000000000777)

RawIOBase:

• io: type RawIOBase

rawRemoveDir:

• mkrmdirImpl: proc rawRemoveDir(dp: PathLike)

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

read_bytes:

• pathlib: proc read_bytes(self: Path): PyBytes

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

readlink:

• links: proc readlink[T](path: PathLike[T]): T
• pathlib: proc readlink(self: Path): Path

read_nstring:

• meth: proc read_nstring(self: Path): string

read_text:

• pathlib: proc read_text(self: Path; encoding = DefEncoding; errors = DefErrors): PyStr

relative_to:

• meth: proc relative_to(self: Path; other: string | Path): Path

ReleaseLevel:

• versionInfo: const ReleaseLevel

relpath:

• path: proc relpath[T](p: PathLike[T]; start = curdir): T

remainder:

• math: proc remainder[F: SomeFloat](x, y: F): F
• n_math: proc remainder[F: SomeFloat](x: F; y: F): F

remove:

• set: proc remove[H](self: var PySet[H]; ele: H)
• collections: proc remove[T](ms: MutableSequence[T]; x: T)
• unlink: proc remove[T](p: PathLike[T])

removedirs:

• utils: proc removedirs(d: PathLike)

removeprefix:

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

removesuffix:

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

rename:

• rename: proc rename[T](src, dst: PathLike[T])
• pathlib: proc rename(self: Path; target: Path): Path
• pathlib: proc rename(self: Path; target: string): Path

replace:

• 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
• init: proc replace(self: datetime; year = self.year; month = self.month; day = self.day; hour = self.hour; minute = self.minute; second = self.second; microsecond = self.microsecond; tzinfo = self.tzinfo; fold = 0): datetime
• rename: proc replace[T](src, dst: PathLike[T])
• pathlib: proc replace(self: Path; target: Path): Path
• pathlib: proc replace(self: Path; target: string): Path

repr:

• dict: template repr(self: PyDict): string
• dict: template repr(self: PyDictItemView): string
• dict: template repr(self: PyDictKeyView): string
• dict: template repr(self: PyDictValueView): string
• list: template repr(self: PyList): 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: template repr(self: PyFrozenSet): string
• set_decl: template 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
• isoformat: proc repr(self: datetime): string
• meth: proc repr(self: timedelta): string
• decl: proc repr(self: timezone): string
• decl: method repr(self: timezone): string
• decl: method repr(self: tzinfo): string
• scandirImpl: proc repr(self: DirEntry): string
• walkImpl: template repr[T](self: WalkRes[T]): string
• enums: proc repr(self: Signals): string
• enums: proc repr(self: Handlers): string
• enums: proc repr(self: Sigmasks): string
• types: proc repr(st: struct_time): string

resetSubsCfg:

• substituteImpl: proc resetSubsCfg(cfg: SubsCfg; excHandle = initRaisesExcHandle(); delimiter = Delimiter)

resolution:

• consts: proc resolution(_: typedesc[datetime]): timedelta
• meth: proc resolution(_: _`gensym1610612824:type): timedelta

reverse:

• list: proc reverse(self: var PyList)
• collections: proc reverse(ms: MutableSequence)

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

rf:

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

Rf:

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

rfind:

• 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

rGamma:

• gamma: proc rGamma[F: SomeFloat](x: F): F

rindex:

• 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:

• 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

rLgamma:

• lgamma: proc rLgamma[F: SomeFloat](x: F): F

RLIM_INFINITY:

• consts: const RLIM_INFINITY

RLIMIT_AS:

• consts: let RLIMIT_AS

RLIMIT_CORE:

• consts: let RLIMIT_CORE

RLIMIT_CPU:

• consts: let RLIMIT_CPU

RLIMIT_DATA:

• consts: let RLIMIT_DATA

RLIMIT_FSIZE:

• consts: let RLIMIT_FSIZE

RLIMIT_MEMLOCK:

• consts: let RLIMIT_MEMLOCK

RLIMIT_MSGQUEUE:

• consts: let RLIMIT_MSGQUEUE

RLIMIT_NICE:

• consts: let RLIMIT_NICE

RLIMIT_NOFILE:

• consts: let RLIMIT_NOFILE

RLIMIT_NPROC:

• consts: let RLIMIT_NPROC

RLIMIT_OFILE:

• consts: let RLIMIT_OFILE

RLIMIT_RSS:

• consts: let RLIMIT_RSS

RLIMIT_RTPRIO:

• consts: let RLIMIT_RTPRIO

RLIMIT_RTTIME:

• consts: let RLIMIT_RTTIME

RLIMIT_SIGPENDING:

• consts: let RLIMIT_SIGPENDING

RLIMIT_STACK:

• consts: let RLIMIT_STACK

rmdir:

• mkrmdir: proc rmdir(path: PathLike)
• mkrmdir: proc rmdir(p: PathLike; dir_fd: int)
• pathlib: proc rmdir(self: Path)

round:

• rounds: proc round(x: float; round: PyTime_round_t): float

round_half_even:

• rounds: proc round_half_even(x: float): float

rounds:

• fenvs: template rounds(fi: typeof(float_info)): int

rpartition:

• 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: 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: PyStr; maxsplit = -1): PyList[PyStr]
• rsplit_whitespace: proc rsplit_whitespace[S](pystr: S; maxsplit = -1): PyList[S]

rstrip:

• 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

RUSAGE_BOTH:

• consts: let RUSAGE_BOTH

RUSAGE_CHILDREN:

• consts: let RUSAGE_CHILDREN

RUSAGE_SELF:

• consts: let RUSAGE_SELF

RUSAGE_THREAD:

• consts: let RUSAGE_THREAD

safe_substitute:

• n_string: macro safe_substitute(templ: Template; mapping: Table; kws: varargs[untyped]): string
• n_string: macro safe_substitute(templ: Template; kws: varargs[untyped]): string
• string: macro safe_substitute(templ: Template; mapping: Mapping; kws: varargs[untyped]): PyStr
• string: macro safe_substitute(templ: Template; kws: varargs[untyped]): PyStr

samefile:

• path: proc samefile(a, b: PathLike): bool
• meth: proc samefile(self: Path; other_path: string | Path): bool

sample:

• random: proc sample[T](self: PyRandom; population: Sequence[T]; k: int): PyList[T]
• random: proc sample[T](self: PyRandom; population: Sequence[T]; k: int; counts: Sequence[T]): PyList[ T]
• random: template sample[T](population: Sequence[T]; k: int): PyList[T]
• random: template sample[T](population: Sequence[T]; k: int; counts: Sequence[T]): PyList[T]
• proc_others: proc sample[T](self: PyRandom; population: openArray[T]; k: int): seq[T]
• proc_others: proc sample[T](self: PyRandom; population: openArray[T]; k: int; counts: openArray[T]): seq[ T]
• proc_others: template sample[T](population: openArray[T]; k: int): seq[T]
• proc_others: template sample[T](population: openArray[T]; k: int; counts: openArray[T]): seq[T]

scandir:

• os: template scandir(): untyped
• os: template scandir[T](p: PathLike[T]): untyped
• scandirImpl: proc scandir(): ScandirIterator[PyStr]
• scandirImpl: proc scandir[T](path: PathLike[T]): ScandirIterator[T]
• scandirImpl: iterator scandir(): DirEntry[PyStr]
• scandirImpl: iterator scandir[T](path: PathLike[T]): DirEntry[T]

scandirIter:

• scandirImpl: iterator scandirIter[T](path: T): DirEntry[T]

scipyGammaLn:

• lgamma: proc scipyGammaLn[F: SomeFloat](x: F): F

second:

• inner_decl: proc second(self: datetime): int

seconds:

• getter: proc seconds(self: timedelta): int64

secondsImpl:

• getter: proc secondsImpl(parts: DurationParts): int64

SEC_TO_MS:

• units: const SEC_TO_MS

SEC_TO_NS:

• units: const SEC_TO_NS

SEC_TO_US:

• units: const SEC_TO_US

seed:

• random: proc seed(self: PyRandom; val: int64)
• random: proc seed(self: PyRandom; _: NoneType)
• random: template seed(val: int64)
• random: template seed(_: NoneType)
• proc_dispatched: method seed(self: PyRandom; val = none(int64))
• proc_dispatched: template seed(val = none(int64))

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_consts: const SEEK_CUR

SEEK_DATA:

• seek_consts: template SEEK_DATA(): int

SEEK_END:

• io: const SEEK_END
• seek_consts: const SEEK_END

SEEK_HOLE:

• seek_consts: template SEEK_HOLE(): int

SEEK_SET:

• io: const SEEK_SET
• seek_consts: const SEEK_SET

sep:

• consts: let sep

Sequence:

• collections: type Sequence

Serial:

• versionInfo: const Serial

set:

• set: proc set[H](): PySet[H]
• 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_decl: type set

Set:

• abc_set: type Set

setdefault:

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

setenvOverwrite:

• envutils: proc setenvOverwrite(key, val: string): bool

setErrno:

• errnoUtils: template setErrno(v: untyped)

setErrno0:

• errnoUtils: template setErrno0()

setErrnoRaw:

• errnoUtils: template setErrnoRaw(v: cint)

SET_EXP_MASK:

• consts: template SET_EXP_MASK[F](): untyped

set_handle_inheritable:

• inheritable: proc set_handle_inheritable(handle: int; inheritable: bool)

set_handler:

• state: proc set_handler(i: cint; fn: PySigHandler)

setHighWord:

• common: template setHighWord(x: float; hi)

set_inheritable:

• inheritable: proc set_inheritable(fd: int; inheritable: int | bool)

set_inheritableImpl:

• inheritable: proc set_inheritableImpl(fd: int; inheritable: bool)

setitimer:

• unixs: proc setitimer(which: int; seconds: float; interval = 0.0): tuple[ delay, interval: float]

setLen:

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

setlocale:

• localeutils: template setlocale(category; v: string): cstring

setrlimit:

• funcs: proc setrlimit(resource: int; limits: py_rlimit_abc)

setstate:

• proc_dispatched: proc setstate(state: PyRandomState)
• types: method setstate(self: PyRandom; state: PyRandomState)

set_wakeup_signal:

• signals: proc set_wakeup_signal(signalnum: int): int

shallIgnore:

• walkImpl: const shallIgnore

shuffle:

• random: proc shuffle[T](self: PyRandom; x: var PyList[T])
• random: template shuffle[T](x: var PyList[T])
• proc_others: proc shuffle[T](self: PyRandom; x: var seq[T])
• proc_others: template shuffle[T](x: var seq[T])

shuffleImpl:

• proc_others: template shuffleImpl(self: PyRandom; x)

si_band:

• siginfo_decl: proc si_band(self: struct_siginfo): auto

si_code:

• siginfo_decl: proc si_code(self: struct_siginfo): auto

si_errno:

• siginfo_decl: proc si_errno(self: struct_siginfo): auto

S_IFMT:

• isX: proc S_IFMT(omode: int): int

SIGABRT:

• enums: let SIGABRT

sigaction:

• c_syms: proc sigaction(a1: cint; a2: ptr Sigaction; a3: var Sigaction): cint

SIGALRM:

• enums: let SIGALRM

SIG_BLOCK:

• enums: let SIG_BLOCK

SIGBUS:

• enums: let SIGBUS

SIGCHLD:

• enums: let SIGCHLD

SIGCLD:

• signal: const SIGCLD
• enums: let SIGCLD

SIGCONT:

• enums: let SIGCONT

SIG_DFL:

• enums: let SIG_DFL

SIGEMT:

• signal: const SIGEMT

SIGFPE:

• enums: let SIGFPE

SIGHUP:

• enums: let SIGHUP

SIG_IGN:

• enums: let SIG_IGN

SIGILL:

• enums: let SIGILL

SIGINT:

• enums: let SIGINT

siginterrupt:

• unixs: proc siginterrupt(signalnum, flag: int)

SIGIO:

• signal: const SIGIO
• enums: let SIGIO

SIGIOT:

• signal: const SIGIOT
• enums: let SIGIOT

SIGKILL:

• enums: let SIGKILL

Sigmasks:

• enums: proc Sigmasks(value: int): Sigmasks
• enums: proc Sigmasks(value: Sigmasks): Sigmasks
• enums_decl: type Sigmasks

signal:

• signals: proc signal(signalnum: int; handler: CSigHandler | NimSigHandler | Handlers): PySigHandler
• signals: proc signal(signalnum: int; handler: PySigHandler): PySigHandler

signal_global_state:

• state: template signal_global_state(): signal_state_t

Signals:

• enums: proc Signals(value: int): Signals
• enums: proc Signals(value: Signals): Signals
• enums_decl: type Signals

signal_state_t:

• state: object signal_state_t

sigpending:

• signal: proc sigpending(): PySet[int]
• unixs: proc sigpending(): Set[int]

SIGPIPE:

• enums: let SIGPIPE

SIGPOLL:

• enums: let SIGPOLL

SIGPROF:

• enums: let SIGPROF

SIGPWR:

• signal: const SIGPWR
• enums: let SIGPWR

SIGQUIT:

• enums: let SIGQUIT

SIGRTMAX:

• signal: const SIGRTMAX
• enums: let SIGRTMAX

SIGRTMIN:

• signal: const SIGRTMIN
• enums: let SIGRTMIN

SIGSEGV:

• enums: let SIGSEGV

SIG_SETMASK:

• enums: let SIG_SETMASK

sigset_to_set:

• sigset_to_set: proc sigset_to_set(mask: var Sigset): HashSet[int]

SIGSTKFLT:

• signal: const SIGSTKFLT
• enums: let SIGSTKFLT

SIGSTOP:

• enums: let SIGSTOP

SIGSYS:

• enums: let SIGSYS

SIGTERM:

• enums: let SIGTERM

sigtimedwait:

• unixs: proc sigtimedwait(sigset: Sigset; timeout: Timestamp): struct_siginfo

SIGTRAP:

• enums: let SIGTRAP

SIGTSTP:

• enums: let SIGTSTP

SIGTTIN:

• enums: let SIGTTIN

SIGTTOU:

• enums: let SIGTTOU

SIG_UNBLOCK:

• enums: let SIG_UNBLOCK

SIGURG:

• enums: let SIGURG

SIGUSR1:

• enums: let SIGUSR1

SIGUSR2:

• enums: let SIGUSR2

SIGVTALRM:

• enums: let SIGVTALRM

sigwait:

• unixs: proc sigwait(sigset: Sigset): int

sigwaitinfo:

• unixs: proc sigwaitinfo(sigset: Sigset): struct_siginfo

SIGWINCH:

• signal: const SIGWINCH
• enums: let SIGWINCH

SIGXCPU:

• enums: let SIGXCPU

SIGXFSZ:

• enums: let SIGXFSZ

S_IMODE:

• isX: proc S_IMODE(omode: int): int

S_IMODE_val:

• consts: const S_IMODE_val

sin:

• math: proc sin[F: SomeFloat](x: F): F

sinh:

• math: proc sinh[F: SomeFloat](x: F): F

sinpi:

• sinpi: proc sinpi[F: SomeFloat](x: F): F

si_pid:

• siginfo_decl: proc si_pid(self: struct_siginfo): auto

S_ISBLK:

• isX: proc S_ISBLK(omode: int): bool
• isXImpl: template S_ISBLK(mode`gensym3: Mode): bool

S_ISCHR:

• isX: proc S_ISCHR(omode: int): bool
• isXImpl: template S_ISCHR(mode`gensym1: Mode): bool

S_ISDIR:

• isX: proc S_ISDIR(omode: int): bool
• isXImpl: template S_ISDIR(mode`gensym0: Mode): bool

S_ISDOOR:

• isX: proc S_ISDOOR(omode: int): bool
• isXImpl: template S_ISDOOR(mode: Mode): bool

S_ISFIFO:

• isX: proc S_ISFIFO(omode: int): bool
• isXImpl: template S_ISFIFO(mode`gensym4: Mode): bool

si_signo:

• siginfo_decl: proc si_signo(self: struct_siginfo): auto

S_ISLNK:

• isX: proc S_ISLNK(omode: int): bool
• isXImpl: template S_ISLNK(mode`gensym5: Mode): bool

S_ISPORT:

• isX: proc S_ISPORT(omode: int): bool
• isXImpl: template S_ISPORT(mode: Mode): bool

S_ISREG:

• isX: proc S_ISREG(omode: int): bool
• isXImpl: template S_ISREG(mode`gensym2: Mode): bool

S_ISSOCK:

• isX: proc S_ISSOCK(omode: int): bool
• isXImpl: template S_ISSOCK(mode`gensym6: Mode): bool

si_status:

• siginfo_decl: proc si_status(self: struct_siginfo): auto

S_ISWHT:

• isX: proc S_ISWHT(omode: int): bool
• isXImpl: template S_ISWHT(mode: Mode): bool

si_uid:

• siginfo_decl: proc si_uid(self: struct_siginfo): auto

size:

• wchar_utils: proc size(s): csize_t

Sized:

• collections: type Sized

SIZEOF_RLIMIT_T:

• resource: const SIZEOF_RLIMIT_T

SIZEOF_TIME_T:

• time_t_decl: const SIZEOF_TIME_T

sleep:

• sleep_impl: template sleep(s: int | float)

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

Some_struct_time:

• types: type Some_struct_time

Some_struct_time_tuple:

• types: type Some_struct_time_tuple

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: 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
• path: proc split[T](p: PathLike[T]): (T, T)

splitdrive:

• path: proc splitdrive[T](p: PathLike[T]): (T, T)

splitext:

• path: proc splitext[T](p: PathLike[T]): (T, T)

splitlines:

• 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: 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

sqrt:

• math: proc sqrt[F: SomeFloat](x: F): F

SQRT_TWO_PI:

• consts: const SQRT_TWO_PI

startsWith:

• 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

stat:

• scandirImpl: proc stat(self: DirEntry): stat_result
• stat: proc stat(path: int): stat_result
• stat: proc stat[T](path: PathLike[T]): stat_result
• os_meth: proc stat(self: Path): stat_result

statAttr:

• stat: template statAttr(path: PathLike | int; attr: untyped): untyped

staticErrno:

• singleton_errno: var staticErrno

st_atime:

• stat: proc st_atime(self`gensym0: stat_result): float

st_atime_ns:

• stat: proc st_atime_ns(self`gensym0: stat_result): BiggestInt

stat_result:

• stat: type stat_result

st_ctime:

• stat: proc st_ctime(self`gensym2: stat_result): float

st_ctime_ns:

• stat: proc st_ctime_ns(self`gensym2: stat_result): BiggestInt

stderr:

• stdio: var stderr

stdin:

• stdio: var stdin

stdlibJsGamma:

• gamma: proc stdlibJsGamma[F: SomeFloat](x: F): F

stdlibJsLgamma:

• lgamma: proc stdlibJsLgamma[F: SomeFloat](x: F): F

stdout:

• stdio: var stdout

stem:

• pathlib: proc stem(self: Path): PyStr
• segments: proc stem(self: Path): string

st_mtime:

• stat: proc st_mtime(self`gensym1: stat_result): float

st_mtime_ns:

• stat: proc st_mtime_ns(self`gensym1: stat_result): BiggestInt

StopAsyncIteration:

• signals: object StopAsyncIteration

StopIteration:

• signals: type StopIteration

StopIterationT:

• signals: object StopIterationT

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
• datetime: proc str(self: datetime): PyStr
• datetime: proc str(self: timedelta): PyStr

strerror:

• errnos: proc strerror(e: Errno): string

strftime:

• datetime: proc strftime(self: datetime; format: PyStr): PyStr
• require_time_module: proc strftime(self: datetime; format: string): string
• n_time: proc strftime(format: string): string
• time: proc strftime(format: PyStr): PyStr
• time: proc strftime(format: PyStr; st: Some_struct_time): PyStr
• nstrfptime: proc strftime(format: string; dt: DateTime): string
• strfptime: proc strftime[S](format: S; st: struct_time): S
• strfptime: proc strftime(format: string; st: Some_struct_time_tuple): string
• strfptime: proc strftime(format: string; st: struct_time): string

STRINGLIB_MUTABLE:

• common: const STRINGLIB_MUTABLE

StringLike:

• strimpl: type StringLike

strip:

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

strIterImpl:

• strIter: template strIterImpl(it: typed{atom}; strProc; start, stop: char | string; linear = false; useIter = true): string
• strIter: template strIterImpl(itExpr: typed{~atom}; strProc; start, stop: char | string; linear = false; useIter = true): string

strptime:

• require_time_module: proc strptime(_: _`gensym3556770074:type; datetime_string, format: string): datetime
• n_time: proc strptime(s: string): struct_time
• time: proc strptime(s: PyStr; format = DefaultTimeFormat): struct_time
• nstrfptime: proc strptime(dt: var DateTime; s: string; format_with_sp_asis: string)
• strfptime: proc strptime(s: string; f: string): struct_time

strsignal:

• signal: proc strsignal(signalnum: int): PyStr
• signal_util: proc strsignal(signalnum: int): string

StrTypedTranslateTable:

• translate: type StrTypedTranslateTable

struct_rusage:

• types: type struct_rusage

struct_siginfo:

• siginfo_decl: type struct_siginfo

struct_time:

• converters: proc struct_time(tup`gensym0: struct_time_tuple): struct_time
• converters: proc struct_time(tup`gensym2: struct_time_tuple10): struct_time
• converters: proc struct_time(tup`gensym4: struct_time_tuple11): struct_time
• types: type struct_time

structTimeToDt:

• converters: proc structTimeToDt(st: struct_time; res: var DateTime)

struct_time_tuple:

• types: tuple struct_time_tuple

struct_time_tuple10:

• types: tuple struct_time_tuple10

struct_time_tuple11:

• types: tuple struct_time_tuple11

struct_tm:

• struct_tm_decl: object struct_tm

Subs:

• substituteImpl: type Subs

SubsCfg:

• substituteImpl: type SubsCfg

substitute:

• n_string: macro substitute(templ: Template; mapping: Table; kws: varargs[untyped]): string
• n_string: macro substitute(templ: Template; kws: varargs[untyped]): string
• string: macro substitute(templ: Template; mapping: Mapping; kws: varargs[untyped]): PyStr
• string: macro substitute(templ: Template; kws: varargs[untyped]): PyStr

substituteAux:

• substituteImpl: proc substituteAux[M](templ: string; m: M; excHandle = initRaisesExcHandle(); delimiter = Delimiter): string

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

suffix:

• pathlib: proc suffix(self: Path): PyStr
• segments: proc suffix(self: Path): string

suffixes:

• pathlib: proc suffixes(self: Path): PyList[PyStr]
• segments: proc suffixes(self: Path): seq[string]
• segments: iterator suffixes(self: Path): string

sumprod:

• math: template sumprod[T](p, q: (Iterable[T] and not openArray[T])): float
• math: template sumprod[T](p, q: ClosureIter[T]): float
• math: template sumprod[T](p, q: list[T]): float
• math: template sumprod[T](p, q: openArray[T]): float
• sumprod: proc sumprod[P, Q](p_it: ClosureIter[P]; q_it: ClosureIter[Q]): float
• sumprod: proc sumprod[P, Q](p: openArray[P]; q: openArray[Q]): float

symlink:

• links: proc symlink[T](src, dst: PathLike[T]; target_is_directory = false)
• links: proc symlink[T](src, dst: PathLike[T]; target_is_directory = false; dir_fd: int)

symlink_to:

• pathlib: proc symlink_to(self: Path; target: string | Path; target_is_directory = false)

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

SYS_STAT_H:

• defines: const SYS_STAT_H

system:

• subp: proc system(cmd: string): int

SystemExit:

• simperr: object SystemExit

tan:

• math: proc tan[F: SomeFloat](x: F): F

tanh:

• math: proc tanh[F: SomeFloat](x: F): F

tau:

• n_math: const tau

tell:

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

Template:

• template_decl: type Template
• templateImpl: proc Template(s: string): Template

terminal_size:

• term: tuple terminal_size

TextIOWrapper:

• io: type TextIOWrapper

time:

• measures: proc time(): float

timedelta:

• decl: type timedelta
• meth: proc timedelta(days: FI = 0; seconds: FI = 0; microseconds: FI = 0; milliseconds: FI = 0; minutes: FI = 0; hours: FI = 0; weeks: FI = 0): timedelta
• meth: proc timedelta(days: int64; seconds = 0'i64; microseconds = 0'i64; milliseconds = 0'i64; minutes = 0'i64; hours = 0'i64; weeks = 0'i64): timedelta

TimeDeltaNone:

• decl: const TimeDeltaNone

time_ns:

• measures: proc time_ns(): int64

TimeNsPair:

• utime: tuple TimeNsPair

TimeoutError:

• types: object TimeoutError

TimePair:

• utime: tuple TimePair

Timestamp:

• types: type Timestamp

timestamp:

• getter_requires_op: proc timestamp(self: datetime): float

time_t:

• time_t_decl: type time_t

time_t_overflow:

• exc_util: proc time_t_overflow()

timetuple:

• require_time_module: proc timetuple(self: datetime): struct_time

timezone:

• decl: type timezone
• meth_else: proc timezone(offset: timedelta): timezone
• meth_else: proc timezone(offset: timedelta; name: string): timezone

tinyF:

• expm1: template tinyF[F](): untyped

title:

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

Tm:

• struct_tm_decl: object Tm

toBool:

• pybool: template toBool[T](arg: T): bool
• decl: converter toBool(self: timedelta): bool

toCSEEK:

• seek_consts: template toCSEEK(whence: int): cint

toCSighandler:

• c_py_handler_cvt: proc toCSighandler(p: PySigHandler): CSigHandler

today:

• statics: proc today(_: _`gensym1744830478:type): datetime

toInt:

• enums: converter toInt(self: Handlers): int
• enums: converter toInt(self: Sigmasks): int
• enums: converter toInt(self: Signals): int

toNimBool:

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

toNimIterator:

• niter_types: template toNimIterator[T](x): ClosureIter[T]

toNimSlice:

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

toNimStr:

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

toNimString:

• 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]

toNimTimezone:

• decl: method toNimTimezone(self: timezone): Timezone
• decl: method toNimTimezone(self: tzinfo): Timezone

toordinal:

• getter_of_date: proc toordinal(self: datetime): int

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]

toPyObject:

• types: proc toPyObject(rusage: Rusage): struct_rusage

toPySighandler:

• c_py_handler_cvt: proc toPySighandler(p: CSigHandler | NimSigHandler): PySigHandler

toPySlice:

• pyslice: converter toPySlice(s: PySlice1): PySlice

toPyStr:

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

toSigset:

• unixs: converter toSigset(oa: openArray[int]): Sigset

total_seconds:

• meth: proc total_seconds(self: timedelta): float

toTup:

• walkImpl: converter toTup[T](self: WalkRes[T]): WalkTup[T]

toTuple:

• converters: converter toTuple(st: struct_time): struct_time_tuple

touch:

• touch: proc touch(s: string; mode = 0o000000000666; exist_ok = true)
• os_meth: proc touch(self: Path; mode = 0o000000000666; exist_ok = true)

toWords:

• toWords: proc toWords(x: float): (uint32, uint32)
• toWords: proc toWords(x: float32): (uint16, uint16)

translate:

• 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

triangular:

• random: proc triangular[F: SomeFloat](self: PyRandom; low: F = 0.0; high: F = 1.0; mode: F | NoneType = None): F
• random: template triangular[F: SomeFloat](low: F = 0.0; high: F = 1.0; mode: F | NoneType = None): F
• proc_others: proc triangular[F: SomeFloat](self: PyRandom; low: F = 0.0; high: F = 1.0): F
• proc_others: proc triangular[F: SomeFloat](self: PyRandom; low: F = 0.0; high: F = 1.0; mode: F): F
• proc_others: template triangular[F: SomeFloat](low: F = 0.0; high: F = 1.0): F
• proc_others: template triangular[F: SomeFloat](low: F = 0.0; high: F = 1.0; mode: F): F

True:

• pybool: const True

trunc:

• n_math: proc trunc(x: SomeFloat): int

truncate:

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

tryOsOp:

• oserr: template tryOsOp(raiseCond: bool; body)
• oserr: template tryOsOp(p: PathLike; body)
• oserr: template tryOsOp(p: PathLike; raiseCond: bool; body)
• oserr: template tryOsOp(p1, p2: PathLike; body)

TypedTranslateTableABC:

• translate: type TypedTranslateTableABC

TypeError:

• simperr: object TypeError

tzinfo:

• decl: type tzinfo

tzname:

• datetime: proc tzname(dt: datetime): PyStr
• datetime: method tzname(tz: timezone; dt: datetime): PyStr
• datetime: method tzname(tz: tzinfo; dt: datetime): PyStr
• getter: proc tzname(self: datetime): string
• meth_by_datetime_getter: method tzname(self: timezone; _: datetime): string
• meth_by_datetime_getter: method tzname(self: tzinfo; dt: datetime): string

TzNone:

• decl: const TzNone

tzToNimTimezone:

• decl: template tzToNimTimezone(tz: tzinfo): Timezone

u:

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

ulp:

• math: proc ulp[F: SomeFloat](x: F): F
• nextafter_ulp: proc ulp[F: SomeFloat](x: F): F

uname_release_major:

• platformInfo: proc uname_release_major(): string

uncheckedTruncToInt:

• trunc: proc uncheckedTruncToInt[I: SomeInteger](x: SomeFloat): I

UnicodeDecodeError:

• unicode_err: object UnicodeDecodeError

UnicodeError:

• unicode_err: object UnicodeError

unicodeSpaces:

• consts: const unicodeSpaces

uniform:

• proc_dispatched: proc uniform(self: PyRandom; a, b: float): float
• proc_dispatched: template uniform(a, b: float): float

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

unlink:

• unlink: proc unlink[T](p: PathLike[T])
• pathlib: proc unlink(self: Path; missing_ok: bool)
• os_meth: proc unlink(self: Path)

unlinkImpl:

• unlinkImpl: proc unlinkImpl(p: PathLike)

UNRELIABLE_FMA:

• fma: const UNRELIABLE_FMA

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:

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

urandom:

• os: proc urandom(size: int): PyBytes
• randoms: proc urandom(size: int): seq[uint8]

UserWarning:

• warnings: Warning.UserWarning

UseSmallApprox:

• gamma: template UseSmallApprox[F](_: typedesc[F]): F

US_TO_NS:

• units: const US_TO_NS

UTC:

• decl: let UTC

utc:

• decl: template utc(_: NimTimezoneProc): timezone
• decl: template utc(_: typedesc[timezone]): timezone

utcoffset:

• getter: proc utcoffset(self: datetime): timedelta
• meth_by_datetime_getter: method utcoffset(self: timezone; _: datetime): timedelta
• meth_by_datetime_getter: method utcoffset(self: tzinfo; dt: datetime): timedelta

utc_timezone:

• state_consts: template utc_timezone(): timezone

utc_to_seconds:

• to_seconds_utils: proc utc_to_seconds(year, month, day, hour, minute, second: int): BiggestInt

Utf8:

• fileutils: const Utf8

utf8_decode:

• codecs: proc utf8_decode[STRINGLIB_CHAR](inptr: var (cstring | ptr char); end: (cstring | ptr char); dest: ptr STRINGLIB_CHAR; outpos: var Py_ssize_t): Py_UCS4

utime:

• utime: proc utime[T](path: PathLike[T]; follow_symlinks = true)
• utime: proc utime[T](path: PathLike[T]; ns: TimeNsPair; follow_symlinks = true)
• utime: proc utime[T; F: SomeFloat](path: PathLike[T]; times: TimePair[F]; follow_symlinks = true)

valid_signals:

• n_signal: proc valid_signals(): HashSet[int]
• signal: proc valid_signals(): PySet[int]

value:

• enums: proc value(self: Signals): int
• enums: proc value(self: Handlers): int
• enums: proc value(self: Sigmasks): int

values:

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

Version:

• version: const Version

version:

• n_sys: const version
• sys: const version

version_info:

• n_sys: const version_info
• sys: const version_info

vonmisesvariate:

• proc_others: proc vonmisesvariate(self: PyRandom; mu, kappa: float): float
• proc_others: template vonmisesvariate(mu, kappa: float): float

wait:

• waits: proc wait(): tuple[pid: int, status: int]

wait3:

• waits: proc wait3(options: int): tuple[pid: int, status: int, rusage: struct_rusage]

wait4:

• waits: proc wait4(pid: int; options: int): tuple[pid: int, status: int, rusage: struct_rusage]

waitpid:

• waits: proc waitpid(pid: int; options: int): tuple[pid: int, status: int]

waitstatus_to_exitcode:

• waits: proc waitstatus_to_exitcode(status: int): int

walk:

• walkImpl: proc walk[T](top: PathLike[T]; topdown = True; onerror = shallIgnore; followlinks = False): WalkIterator[T]
• walkImpl: proc walk[T](top: PathLike[T]; topdown = True; onerror = None; followlinks = False): WalkIterator[ T]
• walkImpl: iterator walk[T](top: PathLike[T]; topdown = True; onerror = shallIgnore; followlinks = False): WalkRes[T]
• walkImpl: iterator walk[T](top: PathLike[T]; topdown = True; onerror = None; followlinks = False): WalkRes[ T]

WalkRes:

• walkImpl: type WalkRes

warn:

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

Warning:

• warnings: enum Warning

wchar_t:

• wchar_t: type wchar_t

WCONTINUED:

• waits: let WCONTINUED

WCOREDUMP:

• waits: proc WCOREDUMP(status: int): bool

weekday:

• calendar_utils: proc weekday(year, month, day: int): int
• getter_of_date: proc weekday(self: datetime): int

weibullvariate:

• proc_others: proc weibullvariate(self: PyRandom; alpha, beta: float): float
• proc_others: template weibullvariate(alpha, beta: float): float

weirdTarget:

• util: const weirdTarget

weridTarget:

• platform_utils: const weridTarget

WEXITED:

• waits: let WEXITED

WEXITSTATUS:

• waits: proc WEXITSTATUS(status: int): bool

whenDefErrno:

• loopErrno: template whenDefErrno(res: NimNode; errnoName: string; body): untyped

whitespace:

• string: const whitespace
• consts: const whitespace

WIFCONTINUED:

• waits: proc WIFCONTINUED(status: int): bool

WIFEXITED:

• waits: proc WIFEXITED(status: int): bool

WIFSIGNALED:

• waits: proc WIFSIGNALED(status: int): bool

WIFSTOPPED:

• waits: proc WIFSTOPPED(status: int): bool

with_name:

• segments: proc with_name(self: Path; name: string): Path

with_Py_SUPPRESS_IPH:

• iph_utils: template with_Py_SUPPRESS_IPH(body)

with_suffix:

• segments: proc with_suffix(self: Path; suffix: string): Path

WNOHANG:

• waits: let WNOHANG

WNOWAIT:

• waits: let WNOWAIT

WORDS_BIGENDIAN:

• short_float_repr: const WORDS_BIGENDIAN

WORDS_LITTLEENDIAN:

• short_float_repr: const WORDS_LITTLEENDIAN

wrapTuple:

• converters: template wrapTuple(sym)
• converters: template wrapTuple(sym, tupType)

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

write_bytes:

• pathlib: proc write_bytes(self: Path; b: PyBytes)

write_nstring:

• meth: proc write_nstring(self, s: string)

write_text:

• pathlib: proc write_text(self: Path; data: PyStr; encoding = DefEncoding; errors = DefErrors): int

WSAETIMEDOUT:

• errmap: const WSAETIMEDOUT

WSTOPPED:

• waits: let WSTOPPED

WSTOPSIG:

• waits: proc WSTOPSIG(status: int): bool

WTERMSIG:

• waits: proc WTERMSIG(status: int): bool

wu_import:

• inWordUtilsMapper: macro wu_import(moduleOrfromExpr)

WUNTRACED:

• waits: let WUNTRACED

X87_double_rounding:

• floats: const X87_double_rounding

year:

• inner_decl: proc year(self: datetime): int
• struct_tm_decl: proc year(tm: Tm): int

YMD:

• calendar_utils: tuple YMD

ymd_to_ord:

• calendar_utils: proc ymd_to_ord(year, month, day: int): int
• calendar_utils: proc ymd_to_ord(ymd: YMD): int

YWD:

• calendar_utils: tuple YWD

ZeroDivisionError:

• aritherr: object ZeroDivisionError

zfill:

• 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 = false): Zip[A]
• iters: iterator zip[A, B](it1: Iterable[A]; it2: Iterable[B]; strict = false): (A, B)
• iters: macro zip(iterables_or_strict: varargs[untyped]): Zip

zipIterBodyImpl:

• zipMacro: proc zipIterBodyImpl(iterables: NimNode | seq[NimNode]; strict: NimNode): NimNode

zonename:

• zonename_utils: proc zonename(tm: var Tm): string