Index

Modules: ../builtins/asciiImpl, ../builtins/iters, ../builtins/list, ../builtins/list_decl, ../builtins/private/iterGen, ../builtins/private/mathutils, ../builtins/pyrange, ../builtins/pyslice, ../builtins/reprImpl, ../collections_abc, ../io, ../io_abc, ../noneType, ../private/backendMark, ../private/trans_imp, ../pybool, ../pybytes/bytesbltins, ../pybytes/bytesimpl, ../pyerrors, ../pyerrors/lkuperr, ../pyerrors/oserr, ../pyerrors/rterr, ../pyerrors/simperr, ../pystring/strbltins, ../pystring/strimpl, datetime, datetime_impl/consts, datetime_impl/datetime_impl, datetime_impl/datetime_impl/decl, datetime_impl/datetime_impl/meth, datetime_impl/timedelta_impl, datetime_impl/timedelta_impl/decl, datetime_impl/timedelta_impl/meth, datetime_impl/types, io, n_pathlib, n_time, ncodec, os, os_impl/common, os_impl/consts, os_impl/listcommon, os_impl/listdirx, os_impl/path, os_impl/posix_like, os_impl/posix_like/fdopen, os_impl/posix_like/isatty, os_impl/posix_like/links, 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/stat, os_impl/posix_like/truncate, os_impl/posix_like/unlink, os_impl/posix_like/unlinkImpl, os_impl/posix_like/utime, os_impl/subp, os_impl/term, os_impl/utils, os_impl/walkImpl, pathlib, pathlib_impl/init, pathlib_impl/meth, pathlib_impl/segments, pathlib_impl/types, time, time_impl/asctimeImpl, time_impl/converters, time_impl/measures, time_impl/nstrpftime, 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, 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
• meth: proc `$`(self: timedelta): 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)

`+`:

• 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
• meth: proc `+`(self: timedelta): timedelta
• meth: proc `+`(a, b: timedelta): timedelta

`-`:

• meth: proc `-`(self: timedelta): timedelta
• meth: proc `-`(a, b: timedelta): timedelta

`//`:

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

`/`:

• 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 `/`(head: Path; tail: string): Path
• meth: proc `/`(head: string; tail: Path): Path
• types: proc `/`(head, tail: Path): Path

`<=`:

• pyslice: proc `<=`(self`gensym6: PySlice; o`gensym6: PySlice): 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

`<`:

• pyslice: proc `<`(self`gensym3: PySlice; o`gensym3: PySlice): 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: proc `==`[T](self: PyList[T]; o: openArray[T]): bool
• list: proc `==`[T](self: PyList[T]; o: PyList[T]): bool
• list: proc `==`[T](self: PyList[T]; o: seq[T]): bool
• list: template `==`[T](o: openArray[T]; self: PyList[T]): bool
• list: template `==`[T](o: seq[T]; self: PyList[T]): bool
• pyslice: proc `==`(self: PySlice; o: PySlice): bool
• 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
• meth: proc `==`(self: timedelta; o: timedelta): 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

`@`:

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

`[]`:

• 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
• walkImpl: template `[]`[T](self: WalkRes[T]; i: static int): untyped

`and`:

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

`is`:

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

`not`:

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

`or`:

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

`xor`:

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

`|=`:

• 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

addFields:

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

all:

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

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)

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

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)

asgSeqToObj:

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

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]

basename:

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

bin:

• strbltins: proc bin(a`gensym6: 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

chars:

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

chdir:

• utils: proc chdir(s: PathLike)

chr:

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

clear:

• list: proc clear(self: var PyList)
• collections_abc: proc clear(ms: MutableSequence)

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)

cmpOnField:

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

CmpStragy:

• macro_utils: enum CmpStragy

Collection:

• collections_abc: type Collection

CompileBackend:

• backendMark: enum CompileBackend

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

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:

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

curdir:

• consts: let curdir

cwd:

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

datetime:

• decl: type datetime
• meth: proc datetime(year, month, day: int; hour = 0; minute = 0; second = 0; microsecond = 0): datetime

days:

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

declTupleWithNFieldsFrom:

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

DefaultTimeFormat:

• n_time: const DefaultTimeFormat
• time: const DefaultTimeFormat

DefEncoding:

• io: const DefEncoding

DefErrors:

• ncodec: const DefErrors

DefNewLine:

• io: const DefNewLine

defpath:

• consts: const defpath

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

divmod:

• meth: proc divmod(t1, t2: timedelta): (int64, timedelta)

docTable:

• nstrpftime: const docTable

DocTable:

• doc_utils: object DocTable

dtToStructTime:

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

EncErrors:

• ncodec: enum EncErrors

encoding:

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

enumerate:

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

errnoMsg:

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

errors:

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

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

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

flush:

• io: proc flush(f: IOBase)

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

ftruncate:

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

genIter:

• iterGen: macro genIter(def)

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

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

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

hardlink_to:

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

hasChar:

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

hash:

• types: proc hash(self: Path): int

hex:

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

home:

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

impExp:

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

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)

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

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

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

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

islink:

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

isNotFound:

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

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

isUtcZone:

• types: template isUtcZone(st: struct_time): 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
• 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 | Path](self: Path; pathsegments: varargs[P]): Path

keys:

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

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

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]

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

LookupError:

• lkuperr: object LookupError

makedirs:

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

makeIterable:

• iterGen: template makeIterable(Typ)

map:

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

mapPathLike:

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

Mapping:

• collections_abc: type Mapping

max:

• pyrange: proc max[T](x: PyRange[T]): T
• meth: proc max(_: _`gensym1644167269:type): timedelta

MAXYEAR:

• consts: const MAXYEAR

microseconds:

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

min:

• pyrange: proc min[T](x: PyRange[T]): T
• meth: proc min(_: _`gensym1644167265:type): timedelta

MINYEAR:

• 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: bool; 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))

monotonic:

• measures: proc monotonic(): float

monotonic_ns:

• measures: proc monotonic_ns(): int64

MutableSequence:

• collections_abc: type MutableSequence

name:

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

NCodecInfo:

• ncodec: object NCodecInfo

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]

nimArrayAsList:

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

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

NoneType:

• noneType: type NoneType

noNimsBackend:

• backendMark: template noNimsBackend(def)

normpath:

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

NotADirectoryError:

• oserr: object NotADirectoryError

NotImplDirectives:

• nstrpftime: const NotImplDirectives

NotImplementedError:

• rterr: object NotImplementedError

noWeirdBackend:

• backendMark: template noWeirdBackend(def)

noWeirdTarget:

• oserr: template noWeirdTarget(def)

O_APPEND:

• consts: let O_APPEND

O_CLOEXEC:

• consts: let O_CLOEXEC

O_CREAT:

• consts: let O_CREAT

oct:

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

O_EXCL:

• consts: let O_EXCL

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

ord:

• bytesbltins: proc ord(a: PyBytes): int
• strbltins: proc ord(a: PyStr): 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

O_RDWR:

• consts: let O_RDWR

osErrorMsgWithPath:

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

O_TRUNC:

• consts: let O_TRUNC

O_WRONLY:

• consts: let O_WRONLY

pardir:

• consts: let pardir

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

Path:

• pathlib: proc Path[P: PathLike](pathsegments: varargs[P]): types.Path
• init: proc Path[P: Path | string](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

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

process_time:

• measures: proc process_time(): float

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

PyList:

• list_decl: type PyList

PyRange:

• pyrange: type PyRange

pyrepr:

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

pyreprbImpl:

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

pyreprImpl:

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

PySlice:

• pyslice: type PySlice

PySlice1:

• pyslice: type PySlice1

PyStr:

• strimpl: type PyStr

raiseErrno:

• oserr: proc raiseErrno(additionalInfo = "")

raiseErrnoWithPath:

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

raiseExcWithPath:

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

raiseExcWithPath2:

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

raiseFileExistsError:

• oserr: proc raiseFileExistsError(fp: PathLike)

raiseFileNotFoundError:

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

raiseOsOrFileNotFoundError:

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

range:

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

rangeLen:

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

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

relpath:

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

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:

• 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
• meth: proc repr(self: timedelta): string
• scandirImpl: proc repr(self: DirEntry): string
• walkImpl: template repr[T](self: WalkRes[T]): string
• types: proc repr(st: struct_time): string

resolution:

• meth: proc resolution(_: _`gensym1644167273: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

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]

seconds:

• meth: proc seconds(self: timedelta): 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_END:

• io: const SEEK_END

SEEK_SET:

• io: const SEEK_SET

sep:

• consts: let sep

Sequence:

• collections_abc: type Sequence

setLen:

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

shallIgnore:

• walkImpl: const shallIgnore

Sized:

• collections_abc: type Sized

sleep:

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

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)

stat:

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

statAttr:

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

st_atime:

• stat: template st_atime(s: Stat): untyped

stat_result:

• stat: tuple stat_result

st_ctime:

• stat: template st_ctime(s: Stat): untyped

stem:

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

st_mtime:

• stat: template st_mtime(s: Stat): untyped

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

strftime:

• n_time: proc strftime(format: string): string
• time: proc strftime(format: PyStr): PyStr
• time: proc strftime(format: PyStr; st: Some_struct_time): PyStr
• nstrpftime: 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:

• n_time: proc strptime(s: string): struct_time
• time: proc strptime(s: PyStr; format = DefaultTimeFormat): struct_time
• nstrpftime: 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

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

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

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

time_ns:

• measures: proc time_ns(): int64

TimeNsPair:

• utime: tuple TimeNsPair

TimePair:

• utime: tuple TimePair

toBool:

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

toNimBool:

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

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

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:

• pathlib: proc touch(self: Path; mode = 0o000000000666; exist_ok = true)

True:

• pybool: const True

truncate:

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

tryOsOp:

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

TypeError:

• simperr: object TypeError

unlink:

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

unlinkImpl:

• unlinkImpl: proc unlinkImpl[T](p: PathLike[T]; winIgnoreRO: static[bool] = false): bool

UnsupportedOperation:

• io: object UnsupportedOperation

UserWarning:

• warnings: Warning.UserWarning

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; N](path: PathLike[T]; times: TimePair[N]; follow_symlinks = true)

values:

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

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

with_name:

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

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

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)