Index

Modules: ../Python/fileutils, ../Python/force_ascii_utils, ../Python/internal/pycore_fileutils, ../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/iters, ../builtins/list, ../builtins/list_decl, ../builtins/private/iterGen, ../builtins/private/mathutils, ../builtins/pyrange, ../builtins/pyslice, ../builtins/reprImpl, ../collections_abc, ../io_abc, ../nimpatch/abs, ../nimpatch/utils, ../noneType, ../private/backendMark, ../private/encoding_norm, ../private/trans_imp, ../pybool, ../pybytes/bytesbltins, ../pybytes/bytesimpl, ../pyerrors, ../pyerrors/aritherr, ../pyerrors/errno, ../pyerrors/lkuperr, ../pyerrors/oserr, ../pyerrors/rterr, ../pyerrors/simperr, ../pyerrors/unicode_err, ../pystring/strbltins, ../pystring/strimpl, ../version, 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, errno, io, math, math_impl/cbrt, math_impl/comptime/cbrt, math_impl/constsUtils, math_impl/err, math_impl/errnoUtils, 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/polevl, math_impl/patch/sinpi, math_impl/patch/trunc, math_impl/platformUtils, 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_datetime, n_math, n_pathlib, 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/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/iph_utils, os_impl/private/platform_utils, os_impl/subp, os_impl/term, os_impl/touch, os_impl/utils, os_impl/walkImpl, pathlib, pathlib_impl/init, pathlib_impl/meth, pathlib_impl/os_meth, pathlib_impl/segments, pathlib_impl/types, 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

`$`:

• list: template `$`[T](ls: PyList[T]): string
• pyrange: proc `$`[T](rng: PyRange[T]): string
• io_abc: proc `$`(p: CanIOOpenT): string
• io_abc: proc `$`(p: PathLike): string
• pybool: proc `$`(self: PyBool): string
• bytesimpl: proc `$`(self: PyBytes): string
• strimpl: proc `$`(self: PyStr): 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
• walkImpl: template `$`[T](self: WalkRes[T]): string
• types: proc `$`(p: Path): string

`%`:

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

`*=`:

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

`-=`:

• meth: proc `-=`(mself; t: timedelta)

`-`:

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

`<`:

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

`==`:

• 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
• collections_abc: 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
• 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]
• bytesimpl: proc `@`(self: PyBytes): seq[char]

`[]=`:

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

`[]`:

• 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

`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

`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

`|=`:

• consts: template `|=`(a, b: cint)

`|`:

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

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

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)

addPatch:

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

ALIGNOF_SIZE_T:

• codecs: const ALIGNOF_SIZE_T

all:

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

allocWcharArr:

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

altsep:

• consts: let altsep

any:

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

append:

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

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

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)

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]

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

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

basename:

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

BeforeFixedVer:

• abs: const BeforeFixedVer

BIAS:

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

bin:

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

bool:

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

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

bytes:

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

CanIOOpenT:

• io_abc: type CanIOOpenT

cbrt:

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

ceil:

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

c_fma:

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

chars:

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

chdir:

• utils: proc chdir(s: PathLike)

check_force_ascii:

• force_ascii_utils: proc check_force_ascii(): bool

checkLenientOps:

• list_decl: template checkLenientOps(A, B)

chkOneDay:

• delta_chk: template chkOneDay(delta: timedelta)

chr:

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

c_ldexp:

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

clear:

• list: proc clear(self: var PyList)
• collections_abc: 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:

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

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_abc: type Collection

comb:

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

CompileBackend:

• backendMark: enum CompileBackend

compileLittleEndian:

• assertIsLittleEndian: const compileLittleEndian

CONST_EPOCH:

• state_consts: let CONST_EPOCH

Container:

• collections_abc: type Container

contains:

• pyrange: proc contains[T](x: PyRange[T]; y: T): bool
• collections_abc: proc contains[T](s: Container[T]; x: T): bool
• collections_abc: proc contains[K, V](m: Mapping[K, V]; k: K): bool
• strimpl: proc contains(s: PyStr; c: char): bool
• strimpl: proc contains(s: PyStr; c: PyStr): bool
• strimpl: proc contains(s: PyStr; c: string): bool

copysign:

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

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_abc: proc count[T](s: Sequence[T]; x: T): int

csEq:

• macro_utils: CmpStragy.csEq

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)

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

DefaultTimeFormat:

• n_time: const DefaultTimeFormat
• time: const DefaultTimeFormat

DefEncoding:

• io: const DefEncoding

DefErrors:

• ncodec: const DefErrors

DefNewLine:

• io: const DefNewLine

defpath:

• consts: const defpath

degrees:

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

delitem:

• list: proc delitem(self: var PyList; idx: int)

DeprecationWarning:

• warnings: Warning.DeprecationWarning

devnull:

• consts: const devnull

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

divmod:

• 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

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)

e:

• n_math: const e

EDOM:

• errnoUtils: let EDOM

EINVAL:

• errno_decl: let EINVAL

EncErrors:

• ncodec: enum EncErrors

encoding:

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

encodings.normalize_encoding:

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

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)

epoch:

• to_seconds_utils: let epoch

ERANGE:

• errnoUtils: let ERANGE

erf:

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

erfc:

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

errno:

• errno_decl: var errno

Errno:

• errnoUtils: enum Errno

errnoMsg:

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

errors:

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

EULER:

• consts: const EULER

exit:

• io: template exit(self: IOBase; args: varargs[untyped])

exp:

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

expm1:

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

EXP_MASK:

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

exponent:

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

extend:

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

extsep:

• consts: let extsep

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:

• oserr: object FileExistsError

FileIO:

• io: type FileIO

fileno:

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

FileNotFoundError:

• oserr: object FileNotFoundError

filter:

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

FixedVer:

• abs: const FixedVer

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

format:

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

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)

fromisocalendar:

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

fromisoformat:

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

fromordinal:

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

fromtimestamp:

• statics: proc fromtimestamp(_: _`gensym1828716652: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

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

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

genIter:

• iterGen: macro genIter(def)

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:

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

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

getErrno:

• errnoUtils: template getErrno(): cint

get_handle_inheritable:

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

get_inheritable:

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

getMaxChar:

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

getmtime:

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

getPtr:

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

getsize:

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

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

hardlink_to:

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

hasBug:

• abs: const hasBug

hasChar:

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

hash:

• hashImpl: proc hash(self: datetime): int
• decl: proc hash(self: timedelta): int
• decl: proc hash(self: timezone): int
• types: proc hash(self: Path): int

hashcode:

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

hashcode=:

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

HAVE_MBRTOWC:

• wchar_t: const HAVE_MBRTOWC

HAVE_STRUCT_TM_TM_ZONE:

• struct_tm_decl: const HAVE_STRUCT_TM_TM_ZONE

hex:

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

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

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

impExp:

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

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)

INCOMPLETE_CHARACTER:

• wchar_t: const INCOMPLETE_CHARACTER

index:

• pyrange: proc index[T](r: PyRange[T]; x: T): int
• collections_abc: proc index[T](s: Sequence[T]; x: T; start = 0; stop = -1): int

indices:

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

inf:

• n_math: const inf

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)

initDocTable:

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

initNCodecInfo:

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

initStructTime:

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

initTm:

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

InJs:

• oserr: const InJs

inMicroseconds:

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

insert:

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

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:

• oserr: object IsADirectoryError

isatty:

• io: proc isatty(f: IOBase): bool
• isatty: proc isatty(fd: int): 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

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

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

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

isNotFound:

• oserr: proc isNotFound(err: OSErrorCode): 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

is_symlink:

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

isTimeDeltaNone:

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

isTzNone:

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

isUtcZone:

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

is_valid_wide_char:

• wchar_t: proc is_valid_wide_char(ch: wchar_t): bool

items:

• iters: template items(x: Enumerate): untyped
• iters: template items(x: Filter): untyped
• iters: template items(x: Map): untyped
• iters: template items(x: Reversed): untyped
• iters: template items(x: Zip): untyped
• list_decl: iterator items[T](self: PyList[T]): T
• pyrange: iterator items[T](rng: PyRange[T]): T
• collections_abc: 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]

Iterable:

• collections_abc: type Iterable

Iterator:

• collections_abc: type Iterator

iterdir:

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

join:

• 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

keys:

• collections_abc: template keys[K, V](m: Mapping[K, V]): untyped

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:

• list: template len(self: PyList): int
• pyrange: template len[T](rng: PyRange[T]): 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

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](iter: Iterable[T]): PyList[T]
• list: proc list[T](a: openArray[T]): PyList[T]
• list: proc list[T](x: seq[T]): PyList[T]
• list: proc list[T](): PyList[T]
• list_decl: type list

listdir:

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

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

long:

• pytime: type long

LookupError:

• lkuperr: object LookupError

LOW:

• indices: const LOW

lseek:

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

Major:

• version: const Major

makedirs:

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

makeIterable:

• iterGen: template makeIterable(Typ)

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

mapPathLike:

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

Mapping:

• collections_abc: type Mapping

mapRaiseGammaErr:

• err: proc mapRaiseGammaErr(err: GammaError)

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(_: _`gensym1694498900: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

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

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(_: _`gensym1694498896:type): timedelta

MIN_GAMMA_X:

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

Minor:

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

month:

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

MS_WINDOWS:

• iph_utils: const MS_WINDOWS

MutableSequence:

• collections_abc: type MutableSequence

name:

• consts: const name
• pathlib: proc name(self: Path): PyStr
• segments: proc name(self: Path): string

nan:

• n_math: const nan

NCodecInfo:

• ncodec: object NCodecInfo

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

newNoEncTextIO:

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

newPyList:

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

newPyListOfCap:

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

newPyTimezone:

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

newTimedelta:

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

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

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

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]

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)

NoEncTextIOBase:

• io: type NoEncTextIOBase

NoEncTextIOWrapper:

• io: type NoEncTextIOWrapper

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)

normpath:

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

NotADirectoryError:

• oserr: object NotADirectoryError

NotImplDirectives:

• nstrfptime: const NotImplDirectives

NotImplementedError:

• rterr: object NotImplementedError

notImplErr:

• pyerr: template notImplErr(meth)

now:

• statics: proc now(_: _`gensym1828716562: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)

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

• consts: let O_CLOEXEC

O_CREAT:

• consts: let O_CREAT

oct:

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

O_EXCL:

• consts: let O_EXCL

offset:

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

OnErrorCb:

• walkImpl: type OnErrorCb

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

osErrorMsgWithPath:

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

O_TRUNC:

• consts: let O_TRUNC

O_WRONLY:

• consts: let O_WRONLY

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

parts:

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

Patch:

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

pathsAsOne:

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

pathsep:

• consts: let pathsep

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

pi:

• n_math: const pi

Pinf:

• consts: const Pinf

platformAvail:

• platform_utils: template platformAvail(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:

• list: proc pop[T](self: var PyList[T]): T
• list: proc pop[T](self: var PyList[T]; index: int): T
• collections_abc: proc pop[T](ms: MutableSequence[T]; index = -1): T

pow:

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

prCeiling:

• pytime: PyTime_round_t.prCeiling

prepareROErrno:

• errnoUtils: template prepareROErrno()

prepareRWErrno:

• errnoUtils: template prepareRWErrno()

prFLoor:

• pytime: PyTime_round_t.prFLoor

prHalfEven:

• pytime: PyTime_round_t.prHalfEven

process_time:

• measures: proc process_time(): float

prod:

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

prRoundUp:

• pytime: PyTime_round_t.prRoundUp

prTimeout:

• pytime: const prTimeout

ptrdiff_t:

• ptr_types: type ptrdiff_t

pyasciiImpl:

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

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

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

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

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

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

PyList:

• list_decl: type PyList

PyMajor:

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

• version: const PyMinor

Py_normalize_encoding:

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

PyPatch:

• version: const PyPatch

PyRange:

• pyrange: type PyRange

PyReleaseLevel:

• version: const PyReleaseLevel

pyrepr:

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

pyreprbImpl:

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

pyreprImpl:

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

Py_ResetForceASCII:

• force_ascii_utils: proc Py_ResetForceASCII()

PySerial:

• version: const PySerial

Py_set_inheritable:

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

pysince:

• version: macro pysince(major, minor: static int; def)

PySlice:

• pyslice: type PySlice

PySlice1:

• pyslice: type PySlice1

PyStr:

• strimpl: type PyStr

PyTime_round_t:

• pytime: 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: cint; additionalInfo = "")
• oserr: proc raiseErrno(additionalInfo = "")

raiseErrnoWithPath:

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

raiseExcWithPath:

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

raiseExcWithPath2:

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

raiseFileExistsError:

• oserr: proc raiseFileExistsError(fp: PathLike)

raiseFileNotFoundError:

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

raiseOsOrFileNotFoundError:

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

raiseRangeErr:

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

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:

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

• collections_abc: proc remove[T](ms: MutableSequence[T]; x: T)
• unlink: proc remove[T](p: PathLike[T])

removedirs:

• utils: proc removedirs(d: PathLike)

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:

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

• list: proc repr(ls: PyList[char]): string
• list: template repr[T](ls: PyList[T]): string
• list_decl: proc repr[T: set | string | openArray](self: PyList[T]): string
• pyrange: proc repr[T](rng: PyRange[T]): string
• pyslice: proc repr(self: PySlice): string
• pybool: proc repr(self: PyBool): string
• bytesbltins: proc repr(x: PyBytes): string
• strbltins: proc repr(x: PyStr): 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
• types: proc repr(st: struct_time): string

resolution:

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

reverse:

• list: proc reverse(self: var PyList)
• collections_abc: 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

rGamma:

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

rLgamma:

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

rmdir:

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

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

samefile:

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

scandir:

• 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

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_abc: type Sequence

Serial:

• version: const Serial

setErrno:

• errnoUtils: template setErrno(v: untyped)

setErrno0:

• errnoUtils: template setErrno0()

SET_EXP_MASK:

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

set_handle_inheritable:

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

set_inheritable:

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

set_inheritableImpl:

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

setLen:

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

shallIgnore:

• walkImpl: const shallIgnore

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

size:

• wchar_utils: proc size(s): csize_t

Sized:

• collections_abc: type Sized

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

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:

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

sqrt:

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

SQRT_TWO_PI:

• consts: const SQRT_TWO_PI

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

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

stdlibJsGamma:

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

stdlibJsLgamma:

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

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

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

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

StringLike:

• strimpl: type StringLike

strptime:

• require_time_module: proc strptime(_: _`gensym2684354721: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

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

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

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)

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

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

TimePair:

• utime: tuple TimePair

timestamp:

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

Timestamp:

• pytime: type Timestamp

time_t:

• time_t_decl: type time_t

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

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

today:

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

toNimBool:

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

toNimIterator:

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

toNimSlice:

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

toNimTimezone:

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

toordinal:

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

toPyStr:

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

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)

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(p: PathLike; body)

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

ulp:

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

uncheckedTruncToInt:

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

UnicodeDecodeError:

• unicode_err: object UnicodeDecodeError

UnicodeError:

• unicode_err: object UnicodeError

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

UserWarning:

• warnings: Warning.UserWarning

UseSmallApprox:

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

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)

values:

• collections_abc: iterator values[K, V](m: Mapping[K, V]): V

Version:

• version: const Version

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

weekday:

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

weridTarget:

• platform_utils: const weridTarget

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

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

wu_import:

• inWordUtilsMapper: macro wu_import(moduleOrfromExpr)

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

zip:

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

zonename:

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